mirror of
https://github.com/checkpoint-restore/criu
synced 2025-08-22 18:07:57 +00:00
901d0de945
Start test ./mxcsr --pidfile=mxcsr.pid --outfile=mxcsr.out Run criu dump Unable to kill 44: [Errno 3] No such process <--------------- this one Run criu restore Run criu dump Signed-off-by: Andrei Vagin <avagin@virtuozzo.com> Reviewed-by: Dmitry Safonov <0x7f454c46@gmail.com>
2086 lines
55 KiB
Python
Executable File
2086 lines
55 KiB
Python
Executable File
#!/usr/bin/env python2
|
|
# vim: noet ts=8 sw=8 sts=8
|
|
import argparse
|
|
import glob
|
|
import os
|
|
import subprocess
|
|
import time
|
|
import tempfile
|
|
import shutil
|
|
import re
|
|
import stat
|
|
import signal
|
|
import atexit
|
|
import sys
|
|
import linecache
|
|
import random
|
|
import string
|
|
import imp
|
|
import fcntl
|
|
import errno
|
|
import datetime
|
|
import yaml
|
|
import criu as crpc
|
|
|
|
os.chdir(os.path.dirname(os.path.abspath(__file__)))
|
|
|
|
prev_line = None
|
|
|
|
|
|
def traceit(f, e, a):
|
|
if e == "line":
|
|
lineno = f.f_lineno
|
|
fil = f.f_globals["__file__"]
|
|
if fil.endswith("zdtm.py"):
|
|
global prev_line
|
|
line = linecache.getline(fil, lineno)
|
|
if line == prev_line:
|
|
print " ..."
|
|
else:
|
|
prev_line = line
|
|
print "+%4d: %s" % (lineno, line.rstrip())
|
|
|
|
return traceit
|
|
|
|
|
|
# Root dir for ns and uns flavors. All tests
|
|
# sit in the same dir
|
|
tests_root = None
|
|
|
|
|
|
def clean_tests_root():
|
|
global tests_root
|
|
if tests_root and tests_root[0] == os.getpid():
|
|
os.rmdir(tests_root[1])
|
|
|
|
|
|
def make_tests_root():
|
|
global tests_root
|
|
if not tests_root:
|
|
tests_root = (os.getpid(), tempfile.mkdtemp("", "criu-root-", "/tmp"))
|
|
atexit.register(clean_tests_root)
|
|
return tests_root[1]
|
|
|
|
|
|
# Report generation
|
|
|
|
report_dir = None
|
|
|
|
|
|
def init_report(path):
|
|
global report_dir
|
|
report_dir = path
|
|
if not os.access(report_dir, os.F_OK):
|
|
os.makedirs(report_dir)
|
|
|
|
|
|
def add_to_report(path, tgt_name):
|
|
global report_dir
|
|
if report_dir:
|
|
tgt_path = os.path.join(report_dir, tgt_name)
|
|
att = 0
|
|
while os.access(tgt_path, os.F_OK):
|
|
tgt_path = os.path.join(report_dir, tgt_name + ".%d" % att)
|
|
att += 1
|
|
|
|
ignore = shutil.ignore_patterns('*.socket')
|
|
if os.path.isdir(path):
|
|
shutil.copytree(path, tgt_path, ignore = ignore)
|
|
else:
|
|
if not os.path.exists(os.path.dirname(tgt_path)):
|
|
os.mkdir(os.path.dirname(tgt_path))
|
|
shutil.copy2(path, tgt_path)
|
|
|
|
|
|
def add_to_output(path):
|
|
global report_dir
|
|
if not report_dir:
|
|
return
|
|
|
|
fdi = open(path, "r")
|
|
fdo = open(os.path.join(report_dir, "output"), "a")
|
|
while True:
|
|
buf = fdi.read(1 << 20)
|
|
if not buf:
|
|
break
|
|
fdo.write(buf)
|
|
|
|
|
|
prev_crash_reports = set(glob.glob("/tmp/zdtm-core-*.txt"))
|
|
|
|
|
|
def check_core_files():
|
|
reports = set(glob.glob("/tmp/zdtm-core-*.txt")) - prev_crash_reports
|
|
if not reports:
|
|
return False
|
|
|
|
while subprocess.Popen("ps axf | grep 'abrt\.sh'", shell = True).wait() == 0:
|
|
time.sleep(1)
|
|
|
|
for i in reports:
|
|
add_to_report(i, os.path.basename(i))
|
|
print_sep(i)
|
|
print open(i).read()
|
|
print_sep(i)
|
|
|
|
return True
|
|
|
|
|
|
# Arch we run on
|
|
arch = os.uname()[4]
|
|
|
|
#
|
|
# Flavors
|
|
# h -- host, test is run in the same set of namespaces as criu
|
|
# ns -- namespaces, test is run in itw own set of namespaces
|
|
# uns -- user namespace, the same as above plus user namespace
|
|
#
|
|
|
|
|
|
class host_flavor:
|
|
def __init__(self, opts):
|
|
self.name = "host"
|
|
self.ns = False
|
|
self.root = None
|
|
|
|
def init(self, l_bins, x_bins):
|
|
pass
|
|
|
|
def fini(self):
|
|
pass
|
|
|
|
@staticmethod
|
|
def clean():
|
|
pass
|
|
|
|
|
|
class ns_flavor:
|
|
__root_dirs = ["/bin", "/sbin", "/etc", "/lib", "/lib64", "/dev", "/dev/pts", "/dev/net", "/tmp", "/usr", "/proc"]
|
|
|
|
def __init__(self, opts):
|
|
self.name = "ns"
|
|
self.ns = True
|
|
self.uns = False
|
|
self.root = make_tests_root()
|
|
self.root_mounted = False
|
|
|
|
def __copy_one(self, fname):
|
|
tfname = self.root + fname
|
|
if not os.access(tfname, os.F_OK):
|
|
# Copying should be atomic as tests can be
|
|
# run in parallel
|
|
try:
|
|
os.makedirs(self.root + os.path.dirname(fname))
|
|
except OSError, e:
|
|
if e.errno != errno.EEXIST:
|
|
raise
|
|
dst = tempfile.mktemp(".tso", "", self.root + os.path.dirname(fname))
|
|
shutil.copy2(fname, dst)
|
|
os.rename(dst, tfname)
|
|
|
|
def __copy_libs(self, binary):
|
|
ldd = subprocess.Popen(["ldd", binary], stdout = subprocess.PIPE)
|
|
xl = re.compile('^(linux-gate.so|linux-vdso(64)?.so|not a dynamic)')
|
|
|
|
# This Mayakovsky-style code gets list of libraries a binary
|
|
# needs minus vdso and gate .so-s
|
|
libs = map(lambda x: x[1] == '=>' and x[2] or x[0],
|
|
map(lambda x: x.split(),
|
|
filter(lambda x: not xl.match(x),
|
|
map(lambda x: x.strip(),
|
|
filter(lambda x: x.startswith('\t'), ldd.stdout.readlines())))))
|
|
ldd.wait()
|
|
|
|
for lib in libs:
|
|
if not os.access(lib, os.F_OK):
|
|
raise test_fail_exc("Can't find lib %s required by %s" % (lib, binary))
|
|
self.__copy_one(lib)
|
|
|
|
def __mknod(self, name, rdev = None):
|
|
name = "/dev/" + name
|
|
if not rdev:
|
|
if not os.access(name, os.F_OK):
|
|
print "Skipping %s at root" % name
|
|
return
|
|
else:
|
|
rdev = os.stat(name).st_rdev
|
|
|
|
name = self.root + name
|
|
os.mknod(name, stat.S_IFCHR, rdev)
|
|
os.chmod(name, 0666)
|
|
|
|
def __construct_root(self):
|
|
for dir in self.__root_dirs:
|
|
os.mkdir(self.root + dir)
|
|
os.chmod(self.root + dir, 0777)
|
|
|
|
for ldir in ["/bin", "/sbin", "/lib", "/lib64"]:
|
|
os.symlink(".." + ldir, self.root + "/usr" + ldir)
|
|
|
|
self.__mknod("tty", os.makedev(5, 0))
|
|
self.__mknod("null", os.makedev(1, 3))
|
|
self.__mknod("net/tun")
|
|
self.__mknod("rtc")
|
|
self.__mknod("autofs", os.makedev(10, 235))
|
|
|
|
def __copy_deps(self, deps):
|
|
for d in deps.split('|'):
|
|
if os.access(d, os.F_OK):
|
|
self.__copy_one(d)
|
|
self.__copy_libs(d)
|
|
return
|
|
raise test_fail_exc("Deps check %s failed" % deps)
|
|
|
|
def init(self, l_bins, x_bins):
|
|
subprocess.check_call(["mount", "--make-slave", "--bind", ".", self.root])
|
|
self.root_mounted = True
|
|
|
|
if not os.access(self.root + "/.constructed", os.F_OK):
|
|
with open(os.path.abspath(__file__)) as o:
|
|
fcntl.flock(o, fcntl.LOCK_EX)
|
|
if not os.access(self.root + "/.constructed", os.F_OK):
|
|
print "Construct root for %s" % l_bins[0]
|
|
self.__construct_root()
|
|
os.mknod(self.root + "/.constructed", stat.S_IFREG | 0600)
|
|
|
|
for b in l_bins:
|
|
self.__copy_libs(b)
|
|
for b in x_bins:
|
|
self.__copy_deps(b)
|
|
|
|
def fini(self):
|
|
if self.root_mounted:
|
|
subprocess.check_call(["./umount2", self.root])
|
|
self.root_mounted = False
|
|
|
|
@staticmethod
|
|
def clean():
|
|
for d in ns_flavor.__root_dirs:
|
|
p = './' + d
|
|
print 'Remove %s' % p
|
|
if os.access(p, os.F_OK):
|
|
shutil.rmtree('./' + d)
|
|
|
|
if os.access('./.constructed', os.F_OK):
|
|
os.unlink('./.constructed')
|
|
|
|
|
|
class userns_flavor(ns_flavor):
|
|
def __init__(self, opts):
|
|
ns_flavor.__init__(self, opts)
|
|
self.name = "userns"
|
|
self.uns = True
|
|
|
|
def init(self, l_bins, x_bins):
|
|
# To be able to create roots_yard in CRIU
|
|
os.chmod(".", os.stat(".").st_mode | 0077)
|
|
ns_flavor.init(self, l_bins, x_bins)
|
|
|
|
@staticmethod
|
|
def clean():
|
|
pass
|
|
|
|
|
|
flavors = {'h': host_flavor, 'ns': ns_flavor, 'uns': userns_flavor}
|
|
|
|
#
|
|
# Helpers
|
|
#
|
|
|
|
|
|
def encode_flav(f):
|
|
return (flavors.keys().index(f) + 128)
|
|
|
|
|
|
def decode_flav(i):
|
|
return flavors.get(i - 128, "unknown")
|
|
|
|
|
|
def tail(path):
|
|
p = subprocess.Popen(['tail', '-n1', path],
|
|
stdout = subprocess.PIPE)
|
|
out = p.stdout.readline()
|
|
p.wait()
|
|
return out
|
|
|
|
|
|
def rpidfile(path):
|
|
return open(path).readline().strip()
|
|
|
|
|
|
def wait_pid_die(pid, who, tmo = 30):
|
|
stime = 0.1
|
|
while stime < tmo:
|
|
try:
|
|
os.kill(int(pid), 0)
|
|
except OSError, e:
|
|
break
|
|
|
|
print "Wait for %s(%d) to die for %f" % (who, pid, stime)
|
|
time.sleep(stime)
|
|
stime *= 2
|
|
else:
|
|
subprocess.Popen(["ps", "-p", str(pid)]).wait()
|
|
subprocess.Popen(["ps", "axf", str(pid)]).wait()
|
|
raise test_fail_exc("%s die" % who)
|
|
|
|
|
|
def test_flag(tdesc, flag):
|
|
return flag in tdesc.get('flags', '').split()
|
|
|
|
#
|
|
# Exception thrown when something inside the test goes wrong,
|
|
# e.g. test doesn't start, criu returns with non zero code or
|
|
# test checks fail
|
|
#
|
|
|
|
|
|
class test_fail_exc:
|
|
def __init__(self, step):
|
|
self.step = step
|
|
|
|
|
|
class test_fail_expected_exc:
|
|
def __init__(self, cr_action):
|
|
self.cr_action = cr_action
|
|
|
|
#
|
|
# A test from zdtm/ directory.
|
|
#
|
|
|
|
|
|
class zdtm_test:
|
|
def __init__(self, name, desc, flavor, freezer):
|
|
self.__name = name
|
|
self.__desc = desc
|
|
self.__freezer = None
|
|
self.__make_action('cleanout')
|
|
self.__pid = 0
|
|
self.__flavor = flavor
|
|
self.__freezer = freezer
|
|
self._bins = [name]
|
|
self._env = {}
|
|
self._deps = desc.get('deps', [])
|
|
self.auto_reap = True
|
|
self.__timeout = int(self.__desc.get('timeout') or 30)
|
|
|
|
def __make_action(self, act, env = None, root = None):
|
|
sys.stdout.flush() # Not to let make's messages appear before ours
|
|
tpath = self.__name + '.' + act
|
|
s_args = ['make', '--no-print-directory',
|
|
'-C', os.path.dirname(tpath),
|
|
os.path.basename(tpath)]
|
|
|
|
if env:
|
|
env = dict(os.environ, **env)
|
|
|
|
s = subprocess.Popen(s_args, env = env, cwd = root, close_fds = True,
|
|
preexec_fn = self.__freezer and self.__freezer.attach or None)
|
|
if act == "pid":
|
|
try_run_hook(self, ["--post-start"])
|
|
s.wait()
|
|
|
|
if self.__freezer:
|
|
self.__freezer.freeze()
|
|
|
|
def __pidfile(self):
|
|
return self.__name + '.pid'
|
|
|
|
def __wait_task_die(self):
|
|
wait_pid_die(int(self.__pid), self.__name, self.__timeout)
|
|
|
|
def __add_wperms(self):
|
|
# Add write perms for .out and .pid files
|
|
for b in self._bins:
|
|
p = os.path.dirname(b)
|
|
os.chmod(p, os.stat(p).st_mode | 0222)
|
|
|
|
def start(self):
|
|
self.__flavor.init(self._bins, self._deps)
|
|
|
|
print "Start test"
|
|
|
|
env = self._env
|
|
if not self.__freezer.kernel:
|
|
env['ZDTM_THREAD_BOMB'] = "5"
|
|
|
|
if not test_flag(self.__desc, 'suid'):
|
|
# Numbers should match those in criu
|
|
env['ZDTM_UID'] = "18943"
|
|
env['ZDTM_GID'] = "58467"
|
|
env['ZDTM_GROUPS'] = "27495 48244"
|
|
self.__add_wperms()
|
|
else:
|
|
print "Test is SUID"
|
|
|
|
if self.__flavor.ns:
|
|
env['ZDTM_NEWNS'] = "1"
|
|
env['ZDTM_ROOT'] = self.__flavor.root
|
|
env['PATH'] = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
|
|
|
|
if self.__flavor.uns:
|
|
env['ZDTM_USERNS'] = "1"
|
|
self.__add_wperms()
|
|
if os.getenv("GCOV"):
|
|
criu_dir = os.path.dirname(os.getcwd())
|
|
criu_dir_r = "%s%s" % (self.__flavor.root, criu_dir)
|
|
|
|
env['ZDTM_CRIU'] = os.path.dirname(os.getcwd())
|
|
subprocess.check_call(["mkdir", "-p", criu_dir_r])
|
|
|
|
self.__make_action('pid', env, self.__flavor.root)
|
|
|
|
try:
|
|
os.kill(int(self.getpid()), 0)
|
|
except Exception, e:
|
|
raise test_fail_exc("start: %s" % e)
|
|
|
|
if not self.static():
|
|
# Wait less than a second to give the test chance to
|
|
# move into some semi-random state
|
|
time.sleep(random.random())
|
|
|
|
def kill(self, sig = signal.SIGKILL):
|
|
self.__freezer.thaw()
|
|
if self.__pid:
|
|
print "Send the %d signal to %s" % (sig, self.__pid)
|
|
os.kill(int(self.__pid), sig)
|
|
self.gone(sig == signal.SIGKILL)
|
|
|
|
self.__flavor.fini()
|
|
|
|
def stop(self):
|
|
self.__freezer.thaw()
|
|
self.getpid() # Read the pid from pidfile back
|
|
self.kill(signal.SIGTERM)
|
|
|
|
res = tail(self.__name + '.out')
|
|
if 'PASS' not in res.split():
|
|
if os.access(self.__name + '.out.inprogress', os.F_OK):
|
|
print_sep(self.__name + '.out.inprogress')
|
|
print open(self.__name + '.out.inprogress').read()
|
|
print_sep(self.__name + '.out.inprogress')
|
|
raise test_fail_exc("result check")
|
|
|
|
def getpid(self):
|
|
if self.__pid == 0:
|
|
self.__pid = rpidfile(self.__pidfile())
|
|
|
|
return self.__pid
|
|
|
|
def getname(self):
|
|
return self.__name
|
|
|
|
def __getcropts(self):
|
|
opts = self.__desc.get('opts', '').split() + ["--pidfile", os.path.realpath(self.__pidfile())]
|
|
if self.__flavor.ns:
|
|
opts += ["--root", self.__flavor.root]
|
|
if test_flag(self.__desc, 'crlib'):
|
|
opts += ["-L", os.path.dirname(os.path.realpath(self.__name)) + '/lib']
|
|
return opts
|
|
|
|
def getdopts(self):
|
|
return self.__getcropts() + self.__freezer.getdopts() + self.__desc.get('dopts', '').split()
|
|
|
|
def getropts(self):
|
|
return self.__getcropts() + self.__freezer.getropts() + self.__desc.get('ropts', '').split()
|
|
|
|
def gone(self, force = True):
|
|
if not self.auto_reap:
|
|
pid, status = os.waitpid(int(self.__pid), 0)
|
|
if pid != int(self.__pid):
|
|
raise test_fail_exc("kill pid mess")
|
|
|
|
self.__wait_task_die()
|
|
self.__pid = 0
|
|
if force:
|
|
os.unlink(self.__pidfile())
|
|
|
|
def print_output(self):
|
|
if os.access(self.__name + '.out', os.R_OK):
|
|
print "Test output: " + "=" * 32
|
|
print open(self.__name + '.out').read()
|
|
print " <<< " + "=" * 32
|
|
|
|
def static(self):
|
|
return self.__name.split('/')[1] == 'static'
|
|
|
|
def ns(self):
|
|
return self.__flavor.ns
|
|
|
|
def blocking(self):
|
|
return test_flag(self.__desc, 'crfail')
|
|
|
|
@staticmethod
|
|
def available():
|
|
if not os.access("umount2", os.X_OK):
|
|
subprocess.check_call(["make", "umount2"])
|
|
if not os.access("zdtm_ct", os.X_OK):
|
|
subprocess.check_call(["make", "zdtm_ct"])
|
|
if not os.access("zdtm/lib/libzdtmtst.a", os.F_OK):
|
|
subprocess.check_call(["make", "-C", "zdtm/"])
|
|
subprocess.check_call(["flock", "zdtm_mount_cgroups.lock", "./zdtm_mount_cgroups"])
|
|
|
|
|
|
class inhfd_test:
|
|
def __init__(self, name, desc, flavor, freezer):
|
|
self.__name = os.path.basename(name)
|
|
print "Load %s" % name
|
|
self.__fdtyp = imp.load_source(self.__name, name)
|
|
self.__my_file = None
|
|
self.__peer_pid = 0
|
|
self.__peer_file = None
|
|
self.__peer_file_name = None
|
|
self.__dump_opts = None
|
|
|
|
def start(self):
|
|
self.__message = "".join([random.choice(string.ascii_letters) for _ in range(16)])
|
|
(self.__my_file, peer_file) = self.__fdtyp.create_fds()
|
|
|
|
# Check FDs returned for inter-connection
|
|
self.__my_file.write(self.__message)
|
|
self.__my_file.flush()
|
|
if peer_file.read(16) != self.__message:
|
|
raise test_fail_exc("FDs screwup")
|
|
|
|
start_pipe = os.pipe()
|
|
self.__peer_pid = os.fork()
|
|
if self.__peer_pid == 0:
|
|
os.setsid()
|
|
|
|
getattr(self.__fdtyp, "child_prep", lambda fd: None)(peer_file)
|
|
|
|
os.close(0)
|
|
os.close(1)
|
|
os.close(2)
|
|
self.__my_file.close()
|
|
os.close(start_pipe[0])
|
|
os.close(start_pipe[1])
|
|
try:
|
|
data = peer_file.read(16)
|
|
except Exception, e:
|
|
print "Unable to read a peer file: %s" % e
|
|
sys.exit(1)
|
|
|
|
sys.exit(data == self.__message and 42 or 2)
|
|
|
|
os.close(start_pipe[1])
|
|
os.read(start_pipe[0], 12)
|
|
os.close(start_pipe[0])
|
|
|
|
self.__peer_file_name = self.__fdtyp.filename(peer_file)
|
|
self.__dump_opts = self.__fdtyp.dump_opts(peer_file)
|
|
|
|
def stop(self):
|
|
self.__my_file.write(self.__message)
|
|
self.__my_file.flush()
|
|
pid, status = os.waitpid(self.__peer_pid, 0)
|
|
if not os.WIFEXITED(status) or os.WEXITSTATUS(status) != 42:
|
|
raise test_fail_exc("test failed with %d" % status)
|
|
|
|
def kill(self):
|
|
if self.__peer_pid:
|
|
os.kill(self.__peer_pid, signal.SIGKILL)
|
|
|
|
def getname(self):
|
|
return self.__name
|
|
|
|
def getpid(self):
|
|
return "%s" % self.__peer_pid
|
|
|
|
def gone(self, force = True):
|
|
os.waitpid(self.__peer_pid, 0)
|
|
wait_pid_die(self.__peer_pid, self.__name)
|
|
self.__my_file = None
|
|
self.__peer_file = None
|
|
|
|
def getdopts(self):
|
|
return self.__dump_opts
|
|
|
|
def getropts(self):
|
|
(self.__my_file, self.__peer_file) = self.__fdtyp.create_fds()
|
|
return ["--restore-sibling", "--inherit-fd", "fd[%d]:%s" % (self.__peer_file.fileno(), self.__peer_file_name)]
|
|
|
|
def print_output(self):
|
|
pass
|
|
|
|
def static(self):
|
|
return True
|
|
|
|
def blocking(self):
|
|
return False
|
|
|
|
@staticmethod
|
|
def available():
|
|
pass
|
|
|
|
|
|
class groups_test(zdtm_test):
|
|
def __init__(self, name, desc, flavor, freezer):
|
|
zdtm_test.__init__(self, 'zdtm/lib/groups', desc, flavor, freezer)
|
|
if flavor.ns:
|
|
self.__real_name = name
|
|
self.__subs = map(lambda x: x.strip(), open(name).readlines())
|
|
print "Subs:\n%s" % '\n'.join(self.__subs)
|
|
else:
|
|
self.__real_name = ''
|
|
self.__subs = []
|
|
|
|
self._bins += self.__subs
|
|
self._deps += get_test_desc('zdtm/lib/groups')['deps']
|
|
self._env = {'ZDTM_TESTS': self.__real_name}
|
|
|
|
def __get_start_cmd(self, name):
|
|
tdir = os.path.dirname(name)
|
|
tname = os.path.basename(name)
|
|
|
|
s_args = ['make', '--no-print-directory', '-C', tdir]
|
|
subprocess.check_call(s_args + [tname + '.cleanout'])
|
|
s = subprocess.Popen(s_args + ['--dry-run', tname + '.pid'], stdout = subprocess.PIPE)
|
|
cmd = s.stdout.readlines().pop().strip()
|
|
s.wait()
|
|
|
|
return 'cd /' + tdir + ' && ' + cmd
|
|
|
|
def start(self):
|
|
if (self.__subs):
|
|
with open(self.__real_name + '.start', 'w') as f:
|
|
for test in self.__subs:
|
|
cmd = self.__get_start_cmd(test)
|
|
f.write(cmd + '\n')
|
|
|
|
with open(self.__real_name + '.stop', 'w') as f:
|
|
for test in self.__subs:
|
|
f.write('kill -TERM `cat /%s.pid`\n' % test)
|
|
|
|
zdtm_test.start(self)
|
|
|
|
def stop(self):
|
|
zdtm_test.stop(self)
|
|
|
|
for test in self.__subs:
|
|
res = tail(test + '.out')
|
|
if 'PASS' not in res.split():
|
|
raise test_fail_exc("sub %s result check" % test)
|
|
|
|
|
|
test_classes = {'zdtm': zdtm_test, 'inhfd': inhfd_test, 'groups': groups_test}
|
|
|
|
#
|
|
# CRIU when launched using CLI
|
|
#
|
|
|
|
criu_bin = "../criu/criu"
|
|
crit_bin = "../crit/crit"
|
|
join_ns_file = '/run/netns/zdtm_netns'
|
|
|
|
|
|
class criu_cli:
|
|
@staticmethod
|
|
def run(action, args, fault = None, strace = [], preexec = None, nowait = False):
|
|
env = dict(os.environ, ASAN_OPTIONS = "log_path=asan.log:disable_coredump=0:detect_leaks=0")
|
|
|
|
if fault:
|
|
print "Forcing %s fault" % fault
|
|
env['CRIU_FAULT'] = fault
|
|
|
|
cr = subprocess.Popen(strace + [criu_bin, action] + args, env = env, preexec_fn = preexec)
|
|
if nowait:
|
|
return cr
|
|
return cr.wait()
|
|
|
|
|
|
class criu_rpc_process:
|
|
def wait(self):
|
|
return self.criu.wait_pid(self.pid)
|
|
|
|
def terminate(self):
|
|
os.kill(self.pid, signal.SIGTERM)
|
|
|
|
|
|
class criu_rpc:
|
|
@staticmethod
|
|
def __set_opts(criu, args, ctx):
|
|
while len(args) != 0:
|
|
arg = args.pop(0)
|
|
if arg == '-v4':
|
|
criu.opts.log_level = 4
|
|
continue
|
|
if arg == '-o':
|
|
criu.opts.log_file = args.pop(0)
|
|
continue
|
|
if arg == '-D':
|
|
criu.opts.images_dir_fd = os.open(args.pop(0), os.O_DIRECTORY)
|
|
ctx['imgd'] = criu.opts.images_dir_fd
|
|
continue
|
|
if arg == '-t':
|
|
criu.opts.pid = int(args.pop(0))
|
|
continue
|
|
if arg == '--pidfile':
|
|
ctx['pidf'] = args.pop(0)
|
|
continue
|
|
if arg == '--timeout':
|
|
criu.opts.timeout = int(args.pop(0))
|
|
continue
|
|
if arg == '--restore-detached':
|
|
# Set by service by default
|
|
ctx['rd'] = True
|
|
continue
|
|
if arg == '--root':
|
|
criu.opts.root = args.pop(0)
|
|
continue
|
|
if arg == '--external':
|
|
criu.opts.external.append(args.pop(0))
|
|
continue
|
|
if arg == '--status-fd':
|
|
fd = int(args.pop(0))
|
|
os.write(fd, "\0")
|
|
fcntl.fcntl(fd, fcntl.F_SETFD, fcntl.FD_CLOEXEC)
|
|
continue
|
|
if arg == '--port':
|
|
criu.opts.ps.port = int(args.pop(0))
|
|
continue
|
|
if arg == '--address':
|
|
criu.opts.ps.address = args.pop(0)
|
|
continue
|
|
if arg == '--page-server':
|
|
continue
|
|
if arg == '--prev-images-dir':
|
|
criu.opts.parent_img = args.pop(0)
|
|
continue
|
|
if arg == '--track-mem':
|
|
criu.opts.track_mem = True
|
|
continue
|
|
|
|
raise test_fail_exc('RPC for %s required' % arg)
|
|
|
|
@staticmethod
|
|
def run(action, args, fault = None, strace = [], preexec = None, nowait = False):
|
|
if fault:
|
|
raise test_fail_exc('RPC and FAULT not supported')
|
|
if strace:
|
|
raise test_fail_exc('RPC and SAT not supported')
|
|
if preexec:
|
|
raise test_fail_exc('RPC and PREEXEC not supported')
|
|
|
|
ctx = {} # Object used to keep info untill action is done
|
|
criu = crpc.criu()
|
|
criu.use_binary(criu_bin)
|
|
criu_rpc.__set_opts(criu, args, ctx)
|
|
p = None
|
|
|
|
try:
|
|
if action == 'dump':
|
|
criu.dump()
|
|
elif action == 'pre-dump':
|
|
criu.pre_dump()
|
|
elif action == 'restore':
|
|
if 'rd' not in ctx:
|
|
raise test_fail_exc('RPC Non-detached restore is impossible')
|
|
|
|
res = criu.restore()
|
|
pidf = ctx.get('pidf')
|
|
if pidf:
|
|
open(pidf, 'w').write('%d\n' % res.pid)
|
|
elif action == "page-server":
|
|
res = criu.page_server_chld()
|
|
p = criu_rpc_process()
|
|
p.pid = res.pid
|
|
p.criu = criu
|
|
else:
|
|
raise test_fail_exc('RPC for %s required' % action)
|
|
except crpc.CRIUExceptionExternal, e:
|
|
print "Fail", e
|
|
ret = -1
|
|
else:
|
|
ret = 0
|
|
|
|
imgd = ctx.get('imgd')
|
|
if imgd:
|
|
os.close(imgd)
|
|
|
|
if nowait and ret == 0:
|
|
return p
|
|
|
|
return ret
|
|
|
|
|
|
class criu:
|
|
def __init__(self, opts):
|
|
self.__test = None
|
|
self.__dump_path = None
|
|
self.__iter = 0
|
|
self.__prev_dump_iter = None
|
|
self.__page_server = (opts['page_server'] and True or False)
|
|
self.__remote_lazy_pages = (opts['remote_lazy_pages'] and True or False)
|
|
self.__lazy_pages = (self.__remote_lazy_pages or
|
|
opts['lazy_pages'] and True or False)
|
|
self.__restore_sibling = (opts['sibling'] and True or False)
|
|
self.__join_ns = (opts['join_ns'] and True or False)
|
|
self.__empty_ns = (opts['empty_ns'] and True or False)
|
|
self.__fault = (opts['fault'])
|
|
self.__script = opts['script']
|
|
self.__sat = (opts['sat'] and True or False)
|
|
self.__dedup = (opts['dedup'] and True or False)
|
|
self.__mdedup = (opts['noauto_dedup'] and True or False)
|
|
self.__user = (opts['user'] and True or False)
|
|
self.__leave_stopped = (opts['stop'] and True or False)
|
|
self.__criu = (opts['rpc'] and criu_rpc or criu_cli)
|
|
self.__show_stats = (opts['show_stats'] and True or False)
|
|
self.__lazy_pages_p = None
|
|
self.__page_server_p = None
|
|
|
|
def fini(self):
|
|
if self.__lazy_pages_p:
|
|
ret = self.__lazy_pages_p.wait()
|
|
grep_errors(os.path.join(self.__ddir(), "lazy-pages.log"))
|
|
self.__lazy_pages_p = None
|
|
if ret:
|
|
raise test_fail_exc("criu lazy-pages exited with %s" % ret)
|
|
if self.__page_server_p:
|
|
ret = self.__page_server_p.wait()
|
|
grep_errors(os.path.join(self.__ddir(), "page-server.log"))
|
|
self.__page_server_p = None
|
|
if ret:
|
|
raise test_fail_exc("criu page-server exited with %s" % ret)
|
|
return
|
|
|
|
def logs(self):
|
|
return self.__dump_path
|
|
|
|
def set_test(self, test):
|
|
self.__test = test
|
|
self.__dump_path = "dump/" + test.getname() + "/" + test.getpid()
|
|
if os.path.exists(self.__dump_path):
|
|
for i in xrange(100):
|
|
newpath = self.__dump_path + "." + str(i)
|
|
if not os.path.exists(newpath):
|
|
os.rename(self.__dump_path, newpath)
|
|
break
|
|
else:
|
|
raise test_fail_exc("couldn't find dump dir %s" % self.__dump_path)
|
|
|
|
os.makedirs(self.__dump_path)
|
|
|
|
def cleanup(self):
|
|
if self.__dump_path:
|
|
print "Removing %s" % self.__dump_path
|
|
shutil.rmtree(self.__dump_path)
|
|
|
|
def __ddir(self):
|
|
return os.path.join(self.__dump_path, "%d" % self.__iter)
|
|
|
|
def set_user_id(self):
|
|
# Numbers should match those in zdtm_test
|
|
os.setresgid(58467, 58467, 58467)
|
|
os.setresuid(18943, 18943, 18943)
|
|
|
|
def __criu_act(self, action, opts = [], log = None, nowait = False):
|
|
if not log:
|
|
log = action + ".log"
|
|
|
|
s_args = ["-o", log, "-D", self.__ddir(), "-v4"] + opts
|
|
|
|
with open(os.path.join(self.__ddir(), action + '.cropt'), 'w') as f:
|
|
f.write(' '.join(s_args) + '\n')
|
|
print "Run criu " + action
|
|
|
|
strace = []
|
|
if self.__sat:
|
|
fname = os.path.join(self.__ddir(), action + '.strace')
|
|
print_fname(fname, 'strace')
|
|
strace = ["strace", "-o", fname, '-T']
|
|
if action == 'restore':
|
|
strace += ['-f']
|
|
s_args += ['--action-script', os.getcwd() + '/../scripts/fake-restore.sh']
|
|
|
|
if self.__script:
|
|
s_args += ['--action-script', self.__script]
|
|
|
|
if action == "restore":
|
|
preexec = None
|
|
else:
|
|
preexec = self.__user and self.set_user_id or None
|
|
|
|
__ddir = self.__ddir()
|
|
|
|
status_fds = None
|
|
if nowait:
|
|
status_fds = os.pipe()
|
|
s_args += ["--status-fd", str(status_fds[1])]
|
|
|
|
ns_last_pid = open("/proc/sys/kernel/ns_last_pid").read()
|
|
|
|
ret = self.__criu.run(action, s_args, self.__fault, strace, preexec, nowait)
|
|
|
|
if nowait:
|
|
os.close(status_fds[1])
|
|
if os.read(status_fds[0], 1) != '\0':
|
|
ret = ret.wait()
|
|
raise test_fail_exc("criu %s exited with %s" % (action, ret))
|
|
os.close(status_fds[0])
|
|
return ret
|
|
|
|
grep_errors(os.path.join(__ddir, log))
|
|
if ret != 0:
|
|
if self.__fault and int(self.__fault) < 128:
|
|
try_run_hook(self.__test, ["--fault", action])
|
|
if action == "dump":
|
|
# create a clean directory for images
|
|
os.rename(__ddir, __ddir + ".fail")
|
|
os.mkdir(__ddir)
|
|
os.chmod(__ddir, 0777)
|
|
else:
|
|
# on restore we move only a log file, because we need images
|
|
os.rename(os.path.join(__ddir, log), os.path.join(__ddir, log + ".fail"))
|
|
# restore ns_last_pid to avoid a case when criu gets
|
|
# PID of one of restored processes.
|
|
open("/proc/sys/kernel/ns_last_pid", "w+").write(ns_last_pid)
|
|
# try again without faults
|
|
print "Run criu " + action
|
|
ret = self.__criu.run(action, s_args, False, strace, preexec)
|
|
grep_errors(os.path.join(__ddir, log))
|
|
if ret == 0:
|
|
return
|
|
if self.__test.blocking() or (self.__sat and action == 'restore'):
|
|
raise test_fail_expected_exc(action)
|
|
else:
|
|
raise test_fail_exc("CRIU %s" % action)
|
|
|
|
def show_stats(self, action):
|
|
if not self.__show_stats:
|
|
return
|
|
|
|
subprocess.Popen([crit_bin, "show",
|
|
os.path.join(self.__dump_path,
|
|
str(self.__iter), "stats-%s" % action)]).wait()
|
|
|
|
def dump(self, action, opts = []):
|
|
self.__iter += 1
|
|
os.mkdir(self.__ddir())
|
|
os.chmod(self.__ddir(), 0777)
|
|
|
|
a_opts = ["-t", self.__test.getpid()]
|
|
if self.__prev_dump_iter:
|
|
a_opts += ["--prev-images-dir", "../%d" % self.__prev_dump_iter, "--track-mem"]
|
|
self.__prev_dump_iter = self.__iter
|
|
|
|
if self.__page_server:
|
|
print "Adding page server"
|
|
|
|
ps_opts = ["--port", "12345"]
|
|
if self.__dedup:
|
|
ps_opts += ["--auto-dedup"]
|
|
|
|
self.__page_server_p = self.__criu_act("page-server", opts = ps_opts, nowait = True)
|
|
a_opts += ["--page-server", "--address", "127.0.0.1", "--port", "12345"]
|
|
|
|
a_opts += self.__test.getdopts()
|
|
|
|
if self.__dedup:
|
|
a_opts += ["--auto-dedup"]
|
|
|
|
a_opts += ["--timeout", "10"]
|
|
|
|
criu_dir = os.path.dirname(os.getcwd())
|
|
if os.getenv("GCOV"):
|
|
a_opts.append('--external')
|
|
a_opts.append('mnt[%s]:zdtm' % criu_dir)
|
|
|
|
if self.__leave_stopped:
|
|
a_opts += ['--leave-stopped']
|
|
if self.__empty_ns:
|
|
a_opts += ['--empty-ns', 'net']
|
|
|
|
self.__criu_act(action, opts = a_opts + opts)
|
|
if self.__mdedup and self.__iter > 1:
|
|
self.__criu_act("dedup", opts = [])
|
|
|
|
self.show_stats("dump")
|
|
|
|
if self.__leave_stopped:
|
|
pstree_check_stopped(self.__test.getpid())
|
|
pstree_signal(self.__test.getpid(), signal.SIGKILL)
|
|
|
|
if self.__page_server_p:
|
|
ret = self.__page_server_p.wait()
|
|
grep_errors(os.path.join(self.__ddir(), "page-server.log"))
|
|
self.__page_server_p = None
|
|
if ret:
|
|
raise test_fail_exc("criu page-server exited with %d" % ret)
|
|
|
|
def restore(self):
|
|
r_opts = []
|
|
if self.__restore_sibling:
|
|
r_opts = ["--restore-sibling"]
|
|
self.__test.auto_reap = False
|
|
r_opts += self.__test.getropts()
|
|
if self.__join_ns:
|
|
r_opts.append("--join-ns")
|
|
r_opts.append("net:%s" % join_ns_file)
|
|
if self.__empty_ns:
|
|
r_opts += ['--empty-ns', 'net']
|
|
r_opts += ['--action-script', os.getcwd() + '/empty-netns-prep.sh']
|
|
|
|
self.__prev_dump_iter = None
|
|
criu_dir = os.path.dirname(os.getcwd())
|
|
if os.getenv("GCOV"):
|
|
r_opts.append('--external')
|
|
r_opts.append('mnt[zdtm]:%s' % criu_dir)
|
|
|
|
if self.__lazy_pages:
|
|
lp_opts = []
|
|
if self.__remote_lazy_pages:
|
|
lp_opts += ['--page-server', "--port", "12345"]
|
|
ps_opts = ["--pidfile", "ps.pid",
|
|
"--port", "12345", "--lazy-pages"]
|
|
self.__page_server_p = self.__criu_act("page-server", opts = ps_opts, nowait = True)
|
|
self.__lazy_pages_p = self.__criu_act("lazy-pages", opts = lp_opts, nowait = True)
|
|
r_opts += ["--lazy-pages"]
|
|
|
|
if self.__leave_stopped:
|
|
r_opts += ['--leave-stopped']
|
|
|
|
self.__criu_act("restore", opts = r_opts + ["--restore-detached"])
|
|
self.show_stats("restore")
|
|
|
|
if self.__leave_stopped:
|
|
pstree_check_stopped(self.__test.getpid())
|
|
pstree_signal(self.__test.getpid(), signal.SIGCONT)
|
|
|
|
@staticmethod
|
|
def check(feature):
|
|
return criu_cli.run("check", ["-v0", "--feature", feature]) == 0
|
|
|
|
@staticmethod
|
|
def available():
|
|
if not os.access(criu_bin, os.X_OK):
|
|
print "CRIU binary not built"
|
|
sys.exit(1)
|
|
|
|
def kill(self):
|
|
if self.__lazy_pages_p:
|
|
self.__lazy_pages_p.terminate()
|
|
print "criu lazy-pages exited with %s" % self.__lazy_pages_p.wait()
|
|
grep_errors(os.path.join(self.__ddir(), "lazy-pages.log"))
|
|
self.__lazy_pages_p = None
|
|
if self.__page_server_p:
|
|
self.__page_server_p.terminate()
|
|
print "criu page-server exited with %s" % self.__page_server_p.wait()
|
|
grep_errors(os.path.join(self.__ddir(), "page-server.log"))
|
|
self.__page_server_p = None
|
|
|
|
|
|
def try_run_hook(test, args):
|
|
hname = test.getname() + '.hook'
|
|
if os.access(hname, os.X_OK):
|
|
print "Running %s(%s)" % (hname, ', '.join(args))
|
|
hook = subprocess.Popen([hname] + args)
|
|
if hook.wait() != 0:
|
|
raise test_fail_exc("hook " + " ".join(args))
|
|
|
|
|
|
#
|
|
# Step by step execution
|
|
#
|
|
|
|
do_sbs = False
|
|
|
|
|
|
def init_sbs():
|
|
if sys.stdout.isatty():
|
|
global do_sbs
|
|
do_sbs = True
|
|
else:
|
|
print "Can't do step-by-step in this runtime"
|
|
|
|
|
|
def sbs(what):
|
|
if do_sbs:
|
|
raw_input("Pause at %s. Press any key to continue." % what)
|
|
|
|
|
|
#
|
|
# Main testing entity -- dump (probably with pre-dumps) and restore
|
|
#
|
|
def iter_parm(opt, dflt):
|
|
x = ((opt or str(dflt)) + ":0").split(':')
|
|
return (xrange(0, int(x[0])), float(x[1]))
|
|
|
|
|
|
def cr(cr_api, test, opts):
|
|
if opts['nocr']:
|
|
return
|
|
|
|
cr_api.set_test(test)
|
|
|
|
iters = iter_parm(opts['iters'], 1)
|
|
for i in iters[0]:
|
|
pres = iter_parm(opts['pre'], 0)
|
|
for p in pres[0]:
|
|
if opts['snaps']:
|
|
cr_api.dump("dump", opts = ["--leave-running"])
|
|
else:
|
|
cr_api.dump("pre-dump")
|
|
try_run_hook(test, ["--post-pre-dump"])
|
|
time.sleep(pres[1])
|
|
|
|
sbs('pre-dump')
|
|
|
|
os.environ["ZDTM_TEST_PID"] = str(test.getpid())
|
|
if opts['norst']:
|
|
try_run_hook(test, ["--pre-dump"])
|
|
cr_api.dump("dump", opts = ["--leave-running"])
|
|
else:
|
|
try_run_hook(test, ["--pre-dump"])
|
|
cr_api.dump("dump")
|
|
test.gone()
|
|
sbs('pre-restore')
|
|
try_run_hook(test, ["--pre-restore"])
|
|
cr_api.restore()
|
|
os.environ["ZDTM_TEST_PID"] = str(test.getpid())
|
|
os.environ["ZDTM_IMG_DIR"] = cr_api.logs()
|
|
try_run_hook(test, ["--post-restore"])
|
|
sbs('post-restore')
|
|
|
|
time.sleep(iters[1])
|
|
|
|
|
|
# Additional checks that can be done outside of test process
|
|
|
|
def get_visible_state(test):
|
|
maps = {}
|
|
files = {}
|
|
mounts = {}
|
|
|
|
if not getattr(test, "static", lambda: False)() or \
|
|
not getattr(test, "ns", lambda: False)():
|
|
return ({}, {}, {})
|
|
|
|
r = re.compile('^[0-9]+$')
|
|
pids = filter(lambda p: r.match(p), os.listdir("/proc/%s/root/proc/" % test.getpid()))
|
|
for pid in pids:
|
|
files[pid] = set(os.listdir("/proc/%s/root/proc/%s/fd" % (test.getpid(), pid)))
|
|
|
|
cmaps = [[0, 0, ""]]
|
|
last = 0
|
|
for mp in open("/proc/%s/root/proc/%s/maps" % (test.getpid(), pid)):
|
|
m = map(lambda x: int('0x' + x, 0), mp.split()[0].split('-'))
|
|
|
|
m.append(mp.split()[1])
|
|
|
|
f = "/proc/%s/root/proc/%s/map_files/%s" % (test.getpid(), pid, mp.split()[0])
|
|
if os.access(f, os.F_OK):
|
|
st = os.lstat(f)
|
|
m.append(oct(st.st_mode))
|
|
|
|
if cmaps[last][1] == m[0] and cmaps[last][2] == m[2]:
|
|
cmaps[last][1] = m[1]
|
|
else:
|
|
cmaps.append(m)
|
|
last += 1
|
|
|
|
maps[pid] = set(map(lambda x: '%x-%x %s' % (x[0], x[1], x[2:]), cmaps))
|
|
|
|
cmounts = []
|
|
try:
|
|
r = re.compile("^\S+\s\S+\s\S+\s(\S+)\s(\S+)")
|
|
for m in open("/proc/%s/root/proc/%s/mountinfo" % (test.getpid(), pid)):
|
|
cmounts.append(r.match(m).groups())
|
|
except IOError, e:
|
|
if e.errno != errno.EINVAL:
|
|
raise e
|
|
mounts[pid] = cmounts
|
|
return files, maps, mounts
|
|
|
|
|
|
def check_visible_state(test, state, opts):
|
|
new = get_visible_state(test)
|
|
|
|
for pid in state[0].keys():
|
|
fnew = new[0][pid]
|
|
fold = state[0][pid]
|
|
if fnew != fold:
|
|
print "%s: Old files lost: %s" % (pid, fold - fnew)
|
|
print "%s: New files appeared: %s" % (pid, fnew - fold)
|
|
raise test_fail_exc("fds compare")
|
|
|
|
old_maps = state[1][pid]
|
|
new_maps = new[1][pid]
|
|
if os.getenv("COMPAT_TEST"):
|
|
# the vsyscall vma isn't unmapped from x32 processes
|
|
vsyscall = "ffffffffff600000-ffffffffff601000 ['r-xp']"
|
|
if vsyscall in new_maps and vsyscall not in old_maps:
|
|
new_maps.remove(vsyscall)
|
|
if old_maps != new_maps:
|
|
print "%s: Old maps lost: %s" % (pid, old_maps - new_maps)
|
|
print "%s: New maps appeared: %s" % (pid, new_maps - old_maps)
|
|
if not opts['fault']: # skip parasite blob
|
|
raise test_fail_exc("maps compare")
|
|
|
|
old_mounts = state[2][pid]
|
|
new_mounts = new[2][pid]
|
|
for i in xrange(len(old_mounts)):
|
|
m = old_mounts.pop(0)
|
|
if m in new_mounts:
|
|
new_mounts.remove(m)
|
|
else:
|
|
old_mounts.append(m)
|
|
if old_mounts or new_mounts:
|
|
print "%s: Old mounts lost: %s" % (pid, old_mounts)
|
|
print "%s: New mounts appeared: %s" % (pid, new_mounts)
|
|
raise test_fail_exc("mounts compare")
|
|
|
|
if '--link-remap' in test.getdopts():
|
|
import glob
|
|
link_remap_list = glob.glob(os.path.dirname(test.getname()) + '/link_remap*')
|
|
if link_remap_list:
|
|
print "%s: link-remap files left: %s" % (test.getname(), link_remap_list)
|
|
raise test_fail_exc("link remaps left")
|
|
|
|
|
|
class noop_freezer:
|
|
def __init__(self):
|
|
self.kernel = False
|
|
|
|
def attach(self):
|
|
pass
|
|
|
|
def freeze(self):
|
|
pass
|
|
|
|
def thaw(self):
|
|
pass
|
|
|
|
def getdopts(self):
|
|
return []
|
|
|
|
def getropts(self):
|
|
return []
|
|
|
|
|
|
class cg_freezer:
|
|
def __init__(self, path, state):
|
|
self.__path = '/sys/fs/cgroup/freezer/' + path
|
|
self.__state = state
|
|
self.kernel = True
|
|
|
|
def attach(self):
|
|
if not os.access(self.__path, os.F_OK):
|
|
os.makedirs(self.__path)
|
|
with open(self.__path + '/tasks', 'w') as f:
|
|
f.write('0')
|
|
|
|
def __set_state(self, state):
|
|
with open(self.__path + '/freezer.state', 'w') as f:
|
|
f.write(state)
|
|
|
|
def freeze(self):
|
|
if self.__state.startswith('f'):
|
|
self.__set_state('FROZEN')
|
|
|
|
def thaw(self):
|
|
if self.__state.startswith('f'):
|
|
self.__set_state('THAWED')
|
|
|
|
def getdopts(self):
|
|
return ['--freeze-cgroup', self.__path, '--manage-cgroups']
|
|
|
|
def getropts(self):
|
|
return ['--manage-cgroups']
|
|
|
|
|
|
def get_freezer(desc):
|
|
if not desc:
|
|
return noop_freezer()
|
|
|
|
fd = desc.split(':')
|
|
fr = cg_freezer(path = fd[0], state = fd[1])
|
|
return fr
|
|
|
|
|
|
def cmp_ns(ns1, match, ns2, msg):
|
|
ns1_ino = os.stat(ns1).st_ino
|
|
ns2_ino = os.stat(ns2).st_ino
|
|
if eval("%r %s %r" % (ns1_ino, match, ns2_ino)):
|
|
print "%s match (%r %s %r) fail" % (msg, ns1_ino, match, ns2_ino)
|
|
raise test_fail_exc("%s compare" % msg)
|
|
|
|
|
|
def check_joinns_state(t):
|
|
cmp_ns("/proc/%s/ns/net" % t.getpid(), "!=", join_ns_file, "join-ns")
|
|
|
|
|
|
def pstree_each_pid(root_pid):
|
|
f_children_path = "/proc/{0}/task/{0}/children".format(root_pid)
|
|
child_pids = []
|
|
try:
|
|
with open(f_children_path, "r") as f_children:
|
|
pid_line = f_children.readline().strip(" \n")
|
|
if pid_line:
|
|
child_pids += pid_line.split(" ")
|
|
except Exception, e:
|
|
print "Unable to read /proc/*/children: %s" % e
|
|
return # process is dead
|
|
|
|
yield root_pid
|
|
for child_pid in child_pids:
|
|
for pid in pstree_each_pid(child_pid):
|
|
yield pid
|
|
|
|
|
|
def is_proc_stopped(pid):
|
|
def get_thread_status(thread_dir):
|
|
try:
|
|
with open(os.path.join(thread_dir, "status")) as f_status:
|
|
for line in f_status.readlines():
|
|
if line.startswith("State:"):
|
|
return line.split(":", 1)[1].strip().split(" ")[0]
|
|
except Exception, e:
|
|
print "Unable to read a thread status: %s" % e
|
|
pass # process is dead
|
|
return None
|
|
|
|
def is_thread_stopped(status):
|
|
return (status is None) or (status == "T") or (status == "Z")
|
|
|
|
tasks_dir = "/proc/%s/task" % pid
|
|
thread_dirs = []
|
|
try:
|
|
thread_dirs = os.listdir(tasks_dir)
|
|
except Exception, e:
|
|
print "Unable to read threads: %s" % e
|
|
pass # process is dead
|
|
|
|
for thread_dir in thread_dirs:
|
|
thread_status = get_thread_status(os.path.join(tasks_dir, thread_dir))
|
|
if not is_thread_stopped(thread_status):
|
|
return False
|
|
|
|
if not is_thread_stopped(get_thread_status("/proc/%s" % pid)):
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
def pstree_check_stopped(root_pid):
|
|
for pid in pstree_each_pid(root_pid):
|
|
if not is_proc_stopped(pid):
|
|
raise test_fail_exc("CRIU --leave-stopped %s" % pid)
|
|
|
|
|
|
def pstree_signal(root_pid, signal):
|
|
for pid in pstree_each_pid(root_pid):
|
|
try:
|
|
os.kill(int(pid), signal)
|
|
except Exception, e:
|
|
print "Unable to kill %d: %s" % (pid, e)
|
|
pass # process is dead
|
|
|
|
|
|
def do_run_test(tname, tdesc, flavs, opts):
|
|
tcname = tname.split('/')[0]
|
|
tclass = test_classes.get(tcname, None)
|
|
if not tclass:
|
|
print "Unknown test class %s" % tcname
|
|
return
|
|
|
|
if opts['report']:
|
|
init_report(opts['report'])
|
|
if opts['sbs']:
|
|
init_sbs()
|
|
|
|
fcg = get_freezer(opts['freezecg'])
|
|
|
|
for f in flavs:
|
|
print
|
|
print_sep("Run %s in %s" % (tname, f))
|
|
if opts['dry_run']:
|
|
continue
|
|
flav = flavors[f](opts)
|
|
t = tclass(tname, tdesc, flav, fcg)
|
|
cr_api = criu(opts)
|
|
|
|
try:
|
|
t.start()
|
|
s = get_visible_state(t)
|
|
try:
|
|
cr(cr_api, t, opts)
|
|
except test_fail_expected_exc as e:
|
|
if e.cr_action == "dump":
|
|
t.stop()
|
|
else:
|
|
check_visible_state(t, s, opts)
|
|
if opts['join_ns']:
|
|
check_joinns_state(t)
|
|
t.stop()
|
|
cr_api.fini()
|
|
try_run_hook(t, ["--clean"])
|
|
except test_fail_exc as e:
|
|
print_sep("Test %s FAIL at %s" % (tname, e.step), '#')
|
|
t.print_output()
|
|
t.kill()
|
|
cr_api.kill()
|
|
try_run_hook(t, ["--clean"])
|
|
if cr_api.logs():
|
|
add_to_report(cr_api.logs(), tname.replace('/', '_') + "_" + f + "/images")
|
|
if opts['keep_img'] == 'never':
|
|
cr_api.cleanup()
|
|
# When option --keep-going not specified this exit
|
|
# does two things: exits from subprocess and aborts the
|
|
# main script execution on the 1st error met
|
|
sys.exit(encode_flav(f))
|
|
else:
|
|
if opts['keep_img'] != 'always':
|
|
cr_api.cleanup()
|
|
print_sep("Test %s PASS" % tname)
|
|
|
|
|
|
class Launcher:
|
|
def __init__(self, opts, nr_tests):
|
|
self.__opts = opts
|
|
self.__total = nr_tests
|
|
self.__runtest = 0
|
|
self.__nr = 0
|
|
self.__max = int(opts['parallel'] or 1)
|
|
self.__subs = {}
|
|
self.__fail = False
|
|
self.__file_report = None
|
|
self.__junit_file = None
|
|
self.__junit_test_cases = None
|
|
self.__failed = []
|
|
self.__nr_skip = 0
|
|
if self.__max > 1 and self.__total > 1:
|
|
self.__use_log = True
|
|
elif opts['report']:
|
|
self.__use_log = True
|
|
else:
|
|
self.__use_log = False
|
|
|
|
if opts['report'] and (opts['keep_going'] or self.__total == 1):
|
|
global TestSuite, TestCase
|
|
from junit_xml import TestSuite, TestCase
|
|
now = datetime.datetime.now()
|
|
att = 0
|
|
reportname = os.path.join(report_dir, "criu-testreport.tap")
|
|
junitreport = os.path.join(report_dir, "criu-testreport.xml")
|
|
while os.access(reportname, os.F_OK) or os.access(junitreport, os.F_OK):
|
|
reportname = os.path.join(report_dir, "criu-testreport" + ".%d.tap" % att)
|
|
junitreport = os.path.join(report_dir, "criu-testreport" + ".%d.xml" % att)
|
|
att += 1
|
|
|
|
self.__junit_file = open(junitreport, 'a')
|
|
self.__junit_test_cases = []
|
|
|
|
self.__file_report = open(reportname, 'a')
|
|
print >> self.__file_report, "TAP version 13"
|
|
print >> self.__file_report, "# Hardware architecture: " + arch
|
|
print >> self.__file_report, "# Timestamp: " + now.strftime("%Y-%m-%d %H:%M") + " (GMT+1)"
|
|
print >> self.__file_report, "# "
|
|
print >> self.__file_report, "1.." + str(nr_tests)
|
|
self.__taint = open("/proc/sys/kernel/tainted").read()
|
|
if int(self.__taint, 0) != 0:
|
|
print "The kernel is tainted: %r" % self.__taint
|
|
if not opts["ignore_taint"]:
|
|
raise Exception("The kernel is tainted: %r" % self.__taint)
|
|
|
|
def __show_progress(self, msg):
|
|
perc = self.__nr * 16 / self.__total
|
|
print "=== Run %d/%d %s %s" % (self.__nr, self.__total, '=' * perc + '-' * (16 - perc), msg)
|
|
|
|
def skip(self, name, reason):
|
|
print "Skipping %s (%s)" % (name, reason)
|
|
self.__nr += 1
|
|
self.__runtest += 1
|
|
self.__nr_skip += 1
|
|
|
|
if self.__junit_test_cases is not None:
|
|
tc = TestCase(name)
|
|
tc.add_skipped_info(reason)
|
|
self.__junit_test_cases.append(tc)
|
|
if self.__file_report:
|
|
testline = "ok %d - %s # SKIP %s" % (self.__runtest, name, reason)
|
|
print >> self.__file_report, testline
|
|
|
|
def run_test(self, name, desc, flavor):
|
|
|
|
if len(self.__subs) >= self.__max:
|
|
self.wait()
|
|
|
|
taint = open("/proc/sys/kernel/tainted").read()
|
|
if self.__taint != taint:
|
|
raise Exception("The kernel is tainted: %r (%r)" % (taint, self.__taint))
|
|
|
|
if test_flag(desc, 'excl'):
|
|
self.wait_all()
|
|
|
|
self.__nr += 1
|
|
self.__show_progress(name)
|
|
|
|
nd = ('nocr', 'norst', 'pre', 'iters', 'page_server', 'sibling', 'stop', 'empty_ns',
|
|
'fault', 'keep_img', 'report', 'snaps', 'sat', 'script', 'rpc', 'lazy_pages',
|
|
'join_ns', 'dedup', 'sbs', 'freezecg', 'user', 'dry_run', 'noauto_dedup',
|
|
'remote_lazy_pages', 'show_stats')
|
|
arg = repr((name, desc, flavor, {d: self.__opts[d] for d in nd}))
|
|
|
|
if self.__use_log:
|
|
logf = name.replace('/', '_') + ".log"
|
|
log = open(logf, "w")
|
|
else:
|
|
logf = None
|
|
log = None
|
|
|
|
sub = subprocess.Popen(["./zdtm_ct", "zdtm.py"],
|
|
env = dict(os.environ, CR_CT_TEST_INFO = arg),
|
|
stdout = log, stderr = subprocess.STDOUT, close_fds = True)
|
|
self.__subs[sub.pid] = {'sub': sub, 'log': logf, 'name': name, "start": time.time()}
|
|
|
|
if test_flag(desc, 'excl'):
|
|
self.wait()
|
|
|
|
def __wait_one(self, flags):
|
|
pid, status = os.waitpid(0, flags)
|
|
self.__runtest += 1
|
|
if pid != 0:
|
|
sub = self.__subs.pop(pid)
|
|
tc = None
|
|
if self.__junit_test_cases is not None:
|
|
tc = TestCase(sub['name'], elapsed_sec=time.time() - sub['start'])
|
|
self.__junit_test_cases.append(tc)
|
|
if status != 0:
|
|
self.__fail = True
|
|
failed_flavor = decode_flav(os.WEXITSTATUS(status))
|
|
self.__failed.append([sub['name'], failed_flavor])
|
|
if self.__file_report:
|
|
testline = "not ok %d - %s # flavor %s" % (self.__runtest, sub['name'], failed_flavor)
|
|
output = open(sub['log']).read()
|
|
details = {'output': output}
|
|
tc.add_error_info(output = output)
|
|
print >> self.__file_report, testline
|
|
print >> self.__file_report, yaml.dump(details, explicit_start=True, explicit_end=True, default_style='|')
|
|
if sub['log']:
|
|
add_to_output(sub['log'])
|
|
else:
|
|
if self.__file_report:
|
|
testline = "ok %d - %s" % (self.__runtest, sub['name'])
|
|
print >> self.__file_report, testline
|
|
|
|
if sub['log']:
|
|
print open(sub['log']).read()
|
|
os.unlink(sub['log'])
|
|
|
|
return True
|
|
|
|
return False
|
|
|
|
def __wait_all(self):
|
|
while self.__subs:
|
|
self.__wait_one(0)
|
|
|
|
def wait(self):
|
|
self.__wait_one(0)
|
|
while self.__subs:
|
|
if not self.__wait_one(os.WNOHANG):
|
|
break
|
|
if self.__fail and not opts['keep_going']:
|
|
raise test_fail_exc('')
|
|
|
|
def wait_all(self):
|
|
self.__wait_all()
|
|
if self.__fail and not opts['keep_going']:
|
|
raise test_fail_exc('')
|
|
|
|
def finish(self):
|
|
self.__wait_all()
|
|
if not opts['fault'] and check_core_files():
|
|
self.__fail = True
|
|
if self.__file_report:
|
|
ts = TestSuite(opts['title'], self.__junit_test_cases, os.getenv("NODE_NAME"))
|
|
self.__junit_file.write(TestSuite.to_xml_string([ts]))
|
|
self.__file_report.close()
|
|
|
|
if opts['keep_going']:
|
|
if self.__fail:
|
|
print_sep("%d TEST(S) FAILED (TOTAL %d/SKIPPED %d)"
|
|
% (len(self.__failed), self.__total, self.__nr_skip), "#")
|
|
for failed in self.__failed:
|
|
print " * %s(%s)" % (failed[0], failed[1])
|
|
else:
|
|
print_sep("ALL TEST(S) PASSED (TOTAL %d/SKIPPED %d)"
|
|
% (self.__total, self.__nr_skip), "#")
|
|
|
|
if self.__fail:
|
|
print_sep("FAIL", "#")
|
|
sys.exit(1)
|
|
|
|
|
|
def all_tests(opts):
|
|
desc = eval(open(opts['set'] + '.desc').read())
|
|
|
|
files = []
|
|
mask = stat.S_IFREG | stat.S_IXUSR
|
|
for d in os.walk(desc['dir']):
|
|
for f in d[2]:
|
|
fp = os.path.join(d[0], f)
|
|
st = os.lstat(fp)
|
|
if (st.st_mode & mask) != mask:
|
|
continue
|
|
if stat.S_IFMT(st.st_mode) in [stat.S_IFLNK, stat.S_IFSOCK]:
|
|
continue
|
|
files.append(fp)
|
|
excl = map(lambda x: os.path.join(desc['dir'], x), desc['exclude'])
|
|
tlist = filter(lambda x:
|
|
not x.endswith('.checkskip') and
|
|
not x.endswith('.hook') and
|
|
x not in excl,
|
|
map(lambda x: x.strip(), files)
|
|
)
|
|
return tlist
|
|
|
|
|
|
# Descriptor for abstract test not in list
|
|
default_test = {}
|
|
|
|
|
|
def get_test_desc(tname):
|
|
d_path = tname + '.desc'
|
|
if os.access(d_path, os.F_OK) and os.path.getsize(d_path) > 0:
|
|
return eval(open(d_path).read())
|
|
|
|
return default_test
|
|
|
|
|
|
def self_checkskip(tname):
|
|
chs = tname + '.checkskip'
|
|
if os.access(chs, os.X_OK):
|
|
ch = subprocess.Popen([chs])
|
|
return not ch.wait() == 0
|
|
|
|
return False
|
|
|
|
|
|
def print_fname(fname, typ):
|
|
print "=[%s]=> %s" % (typ, fname)
|
|
|
|
|
|
def print_sep(title, sep = "=", width = 80):
|
|
print (" " + title + " ").center(width, sep)
|
|
|
|
|
|
def print_error(line):
|
|
line = line.rstrip()
|
|
print line
|
|
if line.endswith('>'): # combine pie output
|
|
return True
|
|
return False
|
|
|
|
|
|
def grep_errors(fname):
|
|
first = True
|
|
print_next = False
|
|
before = []
|
|
for l in open(fname):
|
|
before.append(l)
|
|
if len(before) > 5:
|
|
before.pop(0)
|
|
if "Error" in l:
|
|
if first:
|
|
print_fname(fname, 'log')
|
|
print_sep("grep Error", "-", 60)
|
|
first = False
|
|
for i in before:
|
|
print_next = print_error(i)
|
|
before = []
|
|
else:
|
|
if print_next:
|
|
print_next = print_error(l)
|
|
if not first:
|
|
print_sep("ERROR OVER", "-", 60)
|
|
|
|
|
|
def run_tests(opts):
|
|
excl = None
|
|
features = {}
|
|
|
|
if opts['pre'] or opts['snaps']:
|
|
if not criu.check("mem_dirty_track"):
|
|
print "Tracking memory is not available"
|
|
return
|
|
|
|
if opts['all']:
|
|
torun = all_tests(opts)
|
|
run_all = True
|
|
elif opts['tests']:
|
|
r = re.compile(opts['tests'])
|
|
torun = filter(lambda x: r.match(x), all_tests(opts))
|
|
run_all = True
|
|
elif opts['test']:
|
|
torun = opts['test']
|
|
run_all = False
|
|
elif opts['from']:
|
|
if not os.access(opts['from'], os.R_OK):
|
|
print "No such file"
|
|
return
|
|
|
|
torun = map(lambda x: x.strip(), open(opts['from']))
|
|
opts['keep_going'] = False
|
|
run_all = True
|
|
else:
|
|
print "Specify test with -t <name> or -a"
|
|
return
|
|
|
|
if opts['keep_going'] and len(torun) < 2:
|
|
print "[WARNING] Option --keep-going is more useful when running multiple tests"
|
|
opts['keep_going'] = False
|
|
|
|
if opts['exclude']:
|
|
excl = re.compile(".*(" + "|".join(opts['exclude']) + ")")
|
|
print "Compiled exclusion list"
|
|
|
|
if opts['report']:
|
|
init_report(opts['report'])
|
|
|
|
if opts['parallel'] and opts['freezecg']:
|
|
print "Parallel launch with freezer not supported"
|
|
opts['parallel'] = None
|
|
|
|
if opts['join_ns']:
|
|
if subprocess.Popen(["ip", "netns", "add", "zdtm_netns"]).wait():
|
|
raise Exception("Unable to create a network namespace")
|
|
if subprocess.Popen(["ip", "netns", "exec", "zdtm_netns", "ip", "link", "set", "up", "dev", "lo"]).wait():
|
|
raise Exception("ip link set up dev lo")
|
|
|
|
if opts['lazy_pages'] or opts['remote_lazy_pages']:
|
|
uffd = criu.check("uffd")
|
|
uffd_noncoop = criu.check("uffd-noncoop")
|
|
if not uffd:
|
|
raise Exception("UFFD is not supported, cannot run with --lazy-pages")
|
|
if not uffd_noncoop:
|
|
# Most tests will work with 4.3 - 4.11
|
|
print "[WARNING] Non-cooperative UFFD is missing, some tests might spuriously fail"
|
|
|
|
launcher = Launcher(opts, len(torun))
|
|
try:
|
|
for t in torun:
|
|
global arch
|
|
|
|
if excl and excl.match(t):
|
|
launcher.skip(t, "exclude")
|
|
continue
|
|
|
|
tdesc = get_test_desc(t)
|
|
if tdesc.get('arch', arch) != arch:
|
|
launcher.skip(t, "arch %s" % tdesc['arch'])
|
|
continue
|
|
|
|
if test_flag(tdesc, 'reqrst') and opts['norst']:
|
|
launcher.skip(t, "restore stage is required")
|
|
continue
|
|
|
|
if run_all and test_flag(tdesc, 'noauto'):
|
|
launcher.skip(t, "manual run only")
|
|
continue
|
|
|
|
feat = tdesc.get('feature', None)
|
|
if feat:
|
|
if feat not in features:
|
|
print "Checking feature %s" % feat
|
|
features[feat] = criu.check(feat)
|
|
|
|
if not features[feat]:
|
|
launcher.skip(t, "no %s feature" % feat)
|
|
continue
|
|
|
|
if self_checkskip(t):
|
|
launcher.skip(t, "checkskip failed")
|
|
continue
|
|
|
|
if opts['user']:
|
|
if test_flag(tdesc, 'suid'):
|
|
launcher.skip(t, "suid test in user mode")
|
|
continue
|
|
if test_flag(tdesc, 'nouser'):
|
|
launcher.skip(t, "criu root prio needed")
|
|
continue
|
|
|
|
if opts['join_ns']:
|
|
if test_flag(tdesc, 'samens'):
|
|
launcher.skip(t, "samens test in the same namespace")
|
|
continue
|
|
|
|
if opts['lazy_pages'] or opts['remote_lazy_pages']:
|
|
if test_flag(tdesc, 'nolazy'):
|
|
launcher.skip(t, "lazy pages are not supported")
|
|
continue
|
|
|
|
if opts['remote_lazy_pages']:
|
|
if test_flag(tdesc, 'noremotelazy'):
|
|
launcher.skip(t, "remote lazy pages are not supported")
|
|
continue
|
|
|
|
test_flavs = tdesc.get('flavor', 'h ns uns').split()
|
|
opts_flavs = (opts['flavor'] or 'h,ns,uns').split(',')
|
|
if opts_flavs != ['best']:
|
|
run_flavs = set(test_flavs) & set(opts_flavs)
|
|
else:
|
|
run_flavs = set([test_flavs.pop()])
|
|
if not criu.check("userns"):
|
|
run_flavs -= set(['uns'])
|
|
if opts['user']:
|
|
# FIXME -- probably uns will make sense
|
|
run_flavs -= set(['ns', 'uns'])
|
|
|
|
# remove ns and uns flavor in join_ns
|
|
if opts['join_ns']:
|
|
run_flavs -= set(['ns', 'uns'])
|
|
if opts['empty_ns']:
|
|
run_flavs -= set(['h'])
|
|
|
|
if run_flavs:
|
|
launcher.run_test(t, tdesc, run_flavs)
|
|
else:
|
|
launcher.skip(t, "no flavors")
|
|
finally:
|
|
launcher.finish()
|
|
if opts['join_ns']:
|
|
subprocess.Popen(["ip", "netns", "delete", "zdtm_netns"]).wait()
|
|
|
|
|
|
sti_fmt = "%-40s%-10s%s"
|
|
|
|
|
|
def show_test_info(t):
|
|
tdesc = get_test_desc(t)
|
|
flavs = tdesc.get('flavor', '')
|
|
return sti_fmt % (t, flavs, tdesc.get('flags', ''))
|
|
|
|
|
|
def list_tests(opts):
|
|
tlist = all_tests(opts)
|
|
if opts['info']:
|
|
print sti_fmt % ('Name', 'Flavors', 'Flags')
|
|
tlist = map(lambda x: show_test_info(x), tlist)
|
|
print '\n'.join(tlist)
|
|
|
|
|
|
class group:
|
|
def __init__(self, tname, tdesc):
|
|
self.__tests = [tname]
|
|
self.__desc = tdesc
|
|
self.__deps = set()
|
|
|
|
def __is_mergeable_desc(self, desc):
|
|
# For now make it full match
|
|
if self.__desc.get('flags') != desc.get('flags'):
|
|
return False
|
|
if self.__desc.get('flavor') != desc.get('flavor'):
|
|
return False
|
|
if self.__desc.get('arch') != desc.get('arch'):
|
|
return False
|
|
if self.__desc.get('opts') != desc.get('opts'):
|
|
return False
|
|
if self.__desc.get('feature') != desc.get('feature'):
|
|
return False
|
|
return True
|
|
|
|
def merge(self, tname, tdesc):
|
|
if not self.__is_mergeable_desc(tdesc):
|
|
return False
|
|
|
|
self.__deps |= set(tdesc.get('deps', []))
|
|
self.__tests.append(tname)
|
|
return True
|
|
|
|
def size(self):
|
|
return len(self.__tests)
|
|
|
|
# common method to write a "meta" auxiliary script (hook/checkskip)
|
|
# which will call all tests' scripts in turn
|
|
def __dump_meta(self, fname, ext):
|
|
scripts = filter(lambda names: os.access(names[1], os.X_OK),
|
|
map(lambda test: (test, test + ext),
|
|
self.__tests))
|
|
if scripts:
|
|
f = open(fname + ext, "w")
|
|
f.write("#!/bin/sh -e\n")
|
|
|
|
for test, script in scripts:
|
|
f.write("echo 'Running %s for %s'\n" % (ext, test))
|
|
f.write('%s "$@"\n' % script)
|
|
|
|
f.write("echo 'All %s scripts OK'\n" % ext)
|
|
f.close()
|
|
os.chmod(fname + ext, 0700)
|
|
|
|
def dump(self, fname):
|
|
f = open(fname, "w")
|
|
for t in self.__tests:
|
|
f.write(t + '\n')
|
|
f.close()
|
|
os.chmod(fname, 0700)
|
|
|
|
if len(self.__desc) or len(self.__deps):
|
|
f = open(fname + '.desc', "w")
|
|
if len(self.__deps):
|
|
self.__desc['deps'] = list(self.__deps)
|
|
f.write(repr(self.__desc))
|
|
f.close()
|
|
|
|
# write "meta" .checkskip and .hook scripts
|
|
self.__dump_meta(fname, '.checkskip')
|
|
self.__dump_meta(fname, '.hook')
|
|
|
|
|
|
def group_tests(opts):
|
|
excl = None
|
|
groups = []
|
|
pend_groups = []
|
|
maxs = int(opts['max_size'])
|
|
|
|
if not os.access("groups", os.F_OK):
|
|
os.mkdir("groups")
|
|
|
|
tlist = all_tests(opts)
|
|
random.shuffle(tlist)
|
|
if opts['exclude']:
|
|
excl = re.compile(".*(" + "|".join(opts['exclude']) + ")")
|
|
print "Compiled exclusion list"
|
|
|
|
for t in tlist:
|
|
if excl and excl.match(t):
|
|
continue
|
|
|
|
td = get_test_desc(t)
|
|
|
|
for g in pend_groups:
|
|
if g.merge(t, td):
|
|
if g.size() == maxs:
|
|
pend_groups.remove(g)
|
|
groups.append(g)
|
|
break
|
|
else:
|
|
g = group(t, td)
|
|
pend_groups.append(g)
|
|
|
|
groups += pend_groups
|
|
|
|
nr = 0
|
|
suf = opts['name'] or 'group'
|
|
|
|
for g in groups:
|
|
if maxs > 1 and g.size() == 1: # Not much point in group test for this
|
|
continue
|
|
|
|
fn = os.path.join("groups", "%s.%d" % (suf, nr))
|
|
g.dump(fn)
|
|
nr += 1
|
|
|
|
print "Generated %d group(s)" % nr
|
|
|
|
|
|
def clean_stuff(opts):
|
|
print "Cleaning %s" % opts['what']
|
|
if opts['what'] == 'nsroot':
|
|
for f in flavors:
|
|
f = flavors[f]
|
|
f.clean()
|
|
|
|
|
|
#
|
|
# main() starts here
|
|
#
|
|
|
|
if 'CR_CT_TEST_INFO' in os.environ:
|
|
# Fork here, since we're new pidns init and are supposed to
|
|
# collect this namespace's zombies
|
|
status = 0
|
|
pid = os.fork()
|
|
if pid == 0:
|
|
tinfo = eval(os.environ['CR_CT_TEST_INFO'])
|
|
do_run_test(tinfo[0], tinfo[1], tinfo[2], tinfo[3])
|
|
else:
|
|
while True:
|
|
wpid, status = os.wait()
|
|
if wpid == pid:
|
|
if os.WIFEXITED(status):
|
|
status = os.WEXITSTATUS(status)
|
|
else:
|
|
status = 1
|
|
break
|
|
|
|
sys.exit(status)
|
|
|
|
p = argparse.ArgumentParser("CRIU test suite")
|
|
p.add_argument("--debug", help = "Print what's being executed", action = 'store_true')
|
|
p.add_argument("--set", help = "Which set of tests to use", default = 'zdtm')
|
|
|
|
sp = p.add_subparsers(help = "Use --help for list of actions")
|
|
|
|
rp = sp.add_parser("run", help = "Run test(s)")
|
|
rp.set_defaults(action = run_tests)
|
|
rp.add_argument("-a", "--all", action = 'store_true')
|
|
rp.add_argument("-t", "--test", help = "Test name", action = 'append')
|
|
rp.add_argument("-T", "--tests", help = "Regexp")
|
|
rp.add_argument("-F", "--from", help = "From file")
|
|
rp.add_argument("-f", "--flavor", help = "Flavor to run")
|
|
rp.add_argument("-x", "--exclude", help = "Exclude tests from --all run", action = 'append')
|
|
|
|
rp.add_argument("--sibling", help = "Restore tests as siblings", action = 'store_true')
|
|
rp.add_argument("--join-ns", help = "Restore tests and join existing namespace", action = 'store_true')
|
|
rp.add_argument("--empty-ns", help = "Restore tests in empty net namespace", action = 'store_true')
|
|
rp.add_argument("--pre", help = "Do some pre-dumps before dump (n[:pause])")
|
|
rp.add_argument("--snaps", help = "Instead of pre-dumps do full dumps", action = 'store_true')
|
|
rp.add_argument("--dedup", help = "Auto-deduplicate images on iterations", action = 'store_true')
|
|
rp.add_argument("--noauto-dedup", help = "Manual deduplicate images on iterations", action = 'store_true')
|
|
rp.add_argument("--nocr", help = "Do not CR anything, just check test works", action = 'store_true')
|
|
rp.add_argument("--norst", help = "Don't restore tasks, leave them running after dump", action = 'store_true')
|
|
rp.add_argument("--stop", help = "Check that --leave-stopped option stops ps tree.", action = 'store_true')
|
|
rp.add_argument("--iters", help = "Do CR cycle several times before check (n[:pause])")
|
|
rp.add_argument("--fault", help = "Test fault injection")
|
|
rp.add_argument("--sat", help = "Generate criu strace-s for sat tool (restore is fake, images are kept)", action = 'store_true')
|
|
rp.add_argument("--sbs", help = "Do step-by-step execution, asking user for keypress to continue", action = 'store_true')
|
|
rp.add_argument("--freezecg", help = "Use freeze cgroup (path:state)")
|
|
rp.add_argument("--user", help = "Run CRIU as regular user", action = 'store_true')
|
|
rp.add_argument("--rpc", help = "Run CRIU via RPC rather than CLI", action = 'store_true')
|
|
|
|
rp.add_argument("--page-server", help = "Use page server dump", action = 'store_true')
|
|
rp.add_argument("-p", "--parallel", help = "Run test in parallel")
|
|
rp.add_argument("--dry-run", help="Don't run tests, just pretend to", action='store_true')
|
|
rp.add_argument("--script", help="Add script to get notified by criu")
|
|
rp.add_argument("-k", "--keep-img", help = "Whether or not to keep images after test",
|
|
choices = ['always', 'never', 'failed'], default = 'failed')
|
|
rp.add_argument("--report", help = "Generate summary report in directory")
|
|
rp.add_argument("--keep-going", help = "Keep running tests in spite of failures", action = 'store_true')
|
|
rp.add_argument("--ignore-taint", help = "Don't care about a non-zero kernel taint flag", action = 'store_true')
|
|
rp.add_argument("--lazy-pages", help = "restore pages on demand", action = 'store_true')
|
|
rp.add_argument("--remote-lazy-pages", help = "simulate lazy migration", action = 'store_true')
|
|
rp.add_argument("--title", help = "A test suite title", default = "criu")
|
|
rp.add_argument("--show-stats", help = "Show criu statistics", action = 'store_true')
|
|
|
|
lp = sp.add_parser("list", help = "List tests")
|
|
lp.set_defaults(action = list_tests)
|
|
lp.add_argument('-i', '--info', help = "Show more info about tests", action = 'store_true')
|
|
|
|
gp = sp.add_parser("group", help = "Generate groups")
|
|
gp.set_defaults(action = group_tests)
|
|
gp.add_argument("-m", "--max-size", help = "Maximum number of tests in group")
|
|
gp.add_argument("-n", "--name", help = "Common name for group tests")
|
|
gp.add_argument("-x", "--exclude", help = "Exclude tests from --all run", action = 'append')
|
|
|
|
cp = sp.add_parser("clean", help = "Clean something")
|
|
cp.set_defaults(action = clean_stuff)
|
|
cp.add_argument("what", choices = ['nsroot'])
|
|
|
|
opts = vars(p.parse_args())
|
|
if opts.get('sat', False):
|
|
opts['keep_img'] = 'always'
|
|
|
|
if opts['debug']:
|
|
sys.settrace(traceit)
|
|
|
|
criu.available()
|
|
for tst in test_classes.values():
|
|
tst.available()
|
|
|
|
opts['action'](opts)
|