def run(test, params, env):
"""
enforce quit test:
steps:
1). boot guest with enforce params
2). guest will quit if flags is not supported in host
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
guest_cpumodel = params.get("cpu_model", "Conroe").split(",")[0]
host_cpumodel = utils_misc.get_host_cpu_models()
host_flags = utils_misc.get_cpu_flags()
extra_flags = params.get("cpu_model_flags", " ")
lack_flags = []
flags = re.findall(r"\+(\w+)", extra_flags)
for flag in flags:
if flag not in host_flags:
lack_flags.append(flag)
force_quit = False
# force quit if flag is not no host
if lack_flags:
force_quit = True
# force quit if 'svm' is added
if "svm" in extra_flags:
force_quit = True
# force quit if guest cpu is not included in host cpu cluster
if guest_cpumodel not in host_cpumodel and guest_cpumodel != "host":
force_quit = True
if "enforce" not in extra_flags:
test.error("pls add 'enforce' params to the cmd line")
msg_unavailable = params.get("msg_unavailable", "").split(":")
msg_unknow = params.get("msg_unknow", "not found")
try:
error_context.context(
"boot guest with -cpu %s,%s" % (guest_cpumodel, extra_flags),
logging.info)
params["start_vm"] = "yes"
env_process.preprocess_vm(test, params, env, params.get("main_vm"))
except Exception as err:
tmp_flag = False
for msg in msg_unavailable:
if msg in str(err):
tmp_flag = True
if tmp_flag or msg_unknow in str(err):
logging.info("unavailable host feature, guest force quit")
else:
test.fail("guest quit with error\n%s" % str(err))
vm = env.get_vm(params["main_vm"])
if force_quit:
if not vm.is_dead():
test.fail("guest didn't enforce quit while flag lacked in host")
def run(test, params, env):
"""
enforce quit test:
steps:
1). boot guest with enforce params
2). guest will quit if flags is not supported in host
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
guest_cpumodel = params.get("cpu_model", "Conroe").split(",")[0]
host_cpumodel = utils_misc.get_host_cpu_models()
host_flags = utils_misc.get_cpu_flags()
extra_flags = params.get("cpu_model_flags", " ")
lack_flags = []
flags = re.findall("\+(\w+)", extra_flags)
for flag in flags:
if flag not in host_flags:
lack_flags.append(flag)
force_quit = False
# force quit if flag is not no host
if lack_flags:
force_quit = True
# force quit if 'svm' is added
if "svm" in extra_flags:
force_quit = True
# force quit if guest cpu is not included in host cpu cluster
if guest_cpumodel not in host_cpumodel and guest_cpumodel != "host":
force_quit = True
if "enforce" not in extra_flags:
raise error.TestError("pls add 'enforce' params to the cmd line")
msg_unavailable = params.get("msg_unavailable", "").split(":")
msg_unknow = params.get("msg_unknow", "not found")
try:
error.context("boot guest with -cpu %s,%s" %
(guest_cpumodel, extra_flags),
logging.info)
params["start_vm"] = "yes"
env_process.preprocess_vm(test, params, env, params.get("main_vm"))
except Exception, err:
tmp_flag = False
for msg in msg_unavailable:
if msg in str(err):
tmp_flag = True
if tmp_flag or msg_unknow in str(err):
logging.info("unavailable host feature, guest force quit")
else:
raise error.TestFail("guest quit with error\n%s" % str(err))
def run(test, params, env):
"""
boot cpu model test:
steps:
1). boot guest with cpu model
2). check flags if enable_check == "yes", otherwise shutdown guest
:param test: QEMU test object
:param params: Dictionary with the test parameters
"""
cpu_vendor = utils_misc.get_cpu_vendor()
host_model = utils_misc.get_host_cpu_models()
model_list = params.get("cpu_model")
if not model_list:
if cpu_vendor == "unknow":
raise error.TestError("unknow cpu vendor")
else:
model_list = params.get("cpu_model_%s" % cpu_vendor,
host_model[-1])
extra_flags = params.get("cpu_model_flags_%s" % cpu_vendor, "")
if extra_flags:
cpu_flags = params.get("cpu_model_flags", "") + extra_flags
params["cpu_model_flags"] = cpu_flags
if model_list:
model_list = model_list.split(" ")
for model in model_list:
if model in host_model or model == "host":
params["cpu_model"] = model
params["start_vm"] = "yes"
env_process.preprocess_vm(test, params, env, params["main_vm"])
# check guest flags
if params.get("enable_check", "no") == "yes":
utils_test.run_virt_sub_test(test,
params,
env,
sub_type="flag_check")
else:
# log in and shutdown guest
utils_test.run_virt_sub_test(test,
params,
env,
sub_type="shutdown")
logging.info("shutdown guest successfully")
else:
if params.get("enable_check", "no") == "yes":
raise error.TestWarn("Can not test %s model on %s host, "
"pls use %s host" %
(model, host_model[0], model))
def run_enforce_quit(test, params, env):
"""
enforce quit test:
steps:
1). boot guest with enforce params
2). guest will quit if flags is not supported in host
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment
"""
guest_cpumodel = params.get("cpu_model", "Conroe").split(",")[0]
host_cpumodel = utils_misc.get_host_cpu_models()
host_flags = utils_misc.get_cpu_flags()
extra_flags = params.get("cpu_model_flags", " ")
lack_flags = []
flags = re.findall("\+(\w+)", extra_flags)
for flag in flags:
if flag not in host_flags:
lack_flags.append(flag)
force_quit = False
# force quit if flag is not no host
if lack_flags:
force_quit = True
# force quit if 'svm' is added
if "svm" in extra_flags:
force_quit = True
# force quit if guest cpu is not included in host cpu cluster
if guest_cpumodel not in host_cpumodel and guest_cpumodel != "host":
force_quit = True
if "enforce" not in extra_flags:
raise error.TestError("pls add 'enforce' params to the cmd line")
msg_res = params.get("msg_restricted", "flag restricted to guest")
msg_lack = params.get("msg_lack", "lacks requested flag")
msg_unknow = params.get("msg_unknow", "not found")
try:
error.context(
"boot guest with -cpu %s,%s" % (guest_cpumodel, extra_flags),
logging.info)
params["start_vm"] = "yes"
env_process.preprocess_vm(test, params, env, params.get("main_vm"))
except Exception, e:
if msg_lack in str(e) or msg_res in str(e) or msg_unknow in str(e):
logging.info("flags lacked in host, guest force quit")
else:
raise error.TestFail("guest quit with error\n%s" % str(e))
def run_boot_cpu_model(test, params, env):
"""
boot cpu model test:
steps:
1). boot guest with cpu model
2). check flags if enable_check == "yes", otherwise shutdown guest
:param test: QEMU test object
:param params: Dictionary with the test parameters
"""
cpu_vendor = utils_misc.get_cpu_vendor()
host_model = utils_misc.get_host_cpu_models()
model_list = params.get("cpu_model")
if not model_list:
if cpu_vendor == "unknow":
raise error.TestError("unknow cpu vendor")
else:
model_list = params.get("cpu_model_%s" % cpu_vendor,
host_model[-1])
extra_flags = params.get("cpu_model_flags_%s" % cpu_vendor, "")
if extra_flags:
cpu_flags = params.get("cpu_model_flags", "") + extra_flags
params["cpu_model_flags"] = cpu_flags
if model_list:
model_list = model_list.split(" ")
for model in model_list:
if model in host_model or model == "host":
params["cpu_model"] = model
params["start_vm"] = "yes"
env_process.preprocess_vm(test, params, env, params["main_vm"])
# check guest flags
if params.get("enable_check", "no") == "yes":
utils_test.run_virt_sub_test(test, params,
env, sub_type="flag_check")
else:
# log in and shutdown guest
utils_test.run_virt_sub_test(test, params,
env, sub_type="shutdown")
logging.info("shutdown guest successfully")
else:
if params.get("enable_check", "no") == "yes":
raise error.TestWarn("Can not test %s model on %s host, "
"pls use %s host" % (model,
host_model[0],
model))
dump_path = params.get("dump_path", default_dump_path)
cpuinfo_file = utils.unmap_url(dump_path, dump_file, dump_path)
host_flags = utils_misc.get_cpu_flags()
vm = env.get_vm(params["main_vm"])
guest_cpumodel = vm.cpuinfo.model
extra_flags = params.get("cpu_model_flags", " ")
error.context("Boot guest with -cpu %s,%s" %
(guest_cpumodel, extra_flags), logging.info)
vm.verify_alive()
timeout = float(params.get("login_timeout", 240))
session = vm.wait_for_login(timeout=timeout)
# Get qemu model
host_cpumodel = utils_misc.get_host_cpu_models()
if guest_cpumodel not in host_cpumodel:
qemu_model = host_cpumodel[0]
else:
qemu_model = guest_cpumodel
error.context("Get model %s support flags" % qemu_model, logging.info)
# Get flags for every reg from model's info
models_info = utils.system_output("cat %s" % cpuinfo_file).split("x86")
model_info = qemu_model_info(models_info, qemu_model)
reg_list = params.get("reg_list", "feature_edx ").split()
model_support_flags = " "
if model_info:
for reg in reg_list:
reg_flags = qemu_support_flag(model_info, reg)
if reg_flags:
def run(test, params, env):
"""
flag_check test:
steps:
1. boot guest with -cpu model,+extra_flags (extra_flags is optional)
a. no defined model_name in cfg file
guest_model = host_model
b. model_name defined in cfg file
guest_model = params.get("cpu_model")
2. get guest flags
3. get expected model flags from dump file
a. -cpu host: qemu_model = host_model
b. guest_model > host_model --> expected_model = host_model
e.g guest_model = Haswell, host_model = Sandybridge
expected_model = Sandybridge
c. guest_model < host_model --> expected_model = guest_model
4. get extra flags
a. add_flags = +flag
1). flag is exposed to guest if it's supported in host
2). flag is not supported to guest if it's unknown in host
3). ignore "check", "enforce" which are params not flag
b. del_flags = -flag
flag is removed if it's supported in guest
c. params check: check lack flag in host include unknow flag
5. compare expected flag with flags in guest
a. out_flags: not supported with some conf, this kinds of flag
will be displayed in dump file, but not in guest.
e.g tsc-dedline is not supported with -M rhel6.3.0
b. option_flags: some flag is generated by kernel which is not
defined in dump file. it's acceptable when display in guest.
e.g rep_good
expected_flags = expected_model_flags + add_flags - del_flags
- out_flags
miss_flag = expected_flags - guest_flags
unexpect_flag = guest_flags - expected_flags - option_flags
:param test: Kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def qemu_model_info(models_list, cpumodel):
"""
Get cpumodel info from models_list
:param models_list: all models info
:param cpumodel: model name
:return: model info of cpumodel
"""
for model in models_list:
if cpumodel in model:
return model
return None
def qemu_support_flag(model_info, reg):
"""
Get register's supported flags from model_info
:param model_info: model_info get from dump file
:param reg: reg name, e.g feature_edx
"""
reg_re = re.compile(r".*%s.*\((.*)\)\n" % reg)
flag = reg_re.search(model_info)
try:
if flag:
return flag.groups()[0]
except Exception as e:
logging.error("Failed to get support flag %s" % e)
def get_all_support_flags():
"""
Get all supported flags with qemu query cmd.
"""
qemu_binary = utils_misc.get_qemu_binary(params)
cmd = qemu_binary + params.get("query_cmd", " -cpu ?")
output = utils.system_output(cmd)
flags_re = re.compile(params.get("pattern", "flags:(.*)"))
flag_list = flags_re.search(output)
flags = []
if flag_list:
for flag in flag_list.groups():
flags += flag
return set(map(utils_misc.Flag, flags))
def get_extra_flag(extra_flags, symbol, lack_check=False):
"""
Get added/removed flags
:param extra_flags: exposed/removed flags. e.g "+sse4.1,+sse4.2"
:param symbol: "+","-"
:return: return all extra_flags if lack_check is true
return host supported flags if lack_check is false
"""
flags = []
re_flags = [_[1:] for _ in extra_flags.split(",") if _ and symbol == _[0]]
for flag in re_flags:
if lack_check:
flags.append(flag)
elif flag in host_flags:
flags.append(flag)
return set(map(utils_misc.Flag, flags))
def get_guest_cpuflags(vm_session):
"""
Get guest system cpuflags.
:param vm_session: session to checked vm.
:return: [corespond flags]
"""
flags_re = re.compile(r"^flags\s*:(.*)$", re.MULTILINE)
out = vm_session.cmd_output("cat /proc/cpuinfo")
try:
flags = flags_re.search(out).groups()[0].split()
return set(map(utils_misc.Flag, flags))
except Exception as e:
logging.error("Failed to get guest cpu flags %s" % e)
utils_misc.Flag.aliases = utils_misc.kvm_map_flags_aliases
# Get all models' info from dump file
dump_file = params.get("dump_file")
default_dump_path = os.path.join(data_dir.get_deps_dir(), "cpuid")
dump_path = params.get("dump_path", default_dump_path)
cpuinfo_file = utils.unmap_url(dump_path, dump_file, dump_path)
host_flags = utils_misc.get_cpu_flags()
vm = env.get_vm(params["main_vm"])
guest_cpumodel = vm.cpuinfo.model
extra_flags = params.get("cpu_model_flags", " ")
error.context("Boot guest with -cpu %s,%s" % (guest_cpumodel, extra_flags), logging.info)
if params.get("start_vm") == "no" and "unknown,check" in extra_flags:
params["start_vm"] = "yes"
try:
vm.create(params=params)
vm.verify_alive()
output = vm.process.get_output()
vm.destroy()
except virt_vm.VMCreateError as detail:
output = str(detail)
if params["qemu_output"] not in output:
raise error.TestFail("no qemu output: %s" % params["qemu_output"])
else:
vm.verify_alive()
timeout = float(params.get("login_timeout", 240))
session = vm.wait_for_login(timeout=timeout)
# Get qemu model
host_cpumodel = utils_misc.get_host_cpu_models()
if guest_cpumodel not in host_cpumodel:
qemu_model = host_cpumodel[0]
else:
qemu_model = guest_cpumodel
error.context("Get model %s support flags" % qemu_model, logging.info)
# Get flags for every reg from model's info
models_info = utils.system_output("cat %s" % cpuinfo_file).split("x86")
model_info = qemu_model_info(models_info, qemu_model)
reg_list = params.get("reg_list", "feature_edx ").split()
model_support_flags = " "
if model_info:
for reg in reg_list:
reg_flags = qemu_support_flag(model_info, reg)
if reg_flags:
model_support_flags += " %s" % reg_flags
model_support_flags = set(map(utils_misc.Flag, model_support_flags.split()))
error.context("Get guest flags", logging.info)
guest_flags = get_guest_cpuflags(session)
error.context("Get expected flag list", logging.info)
# out_flags is definded in dump file, but not in guest
out_flags = params.get("out_flags", " ").split()
out_flags = set(map(utils_misc.Flag, out_flags))
# no_check_flags is definded in all_support_flags, but not in guest and host
no_check_flags = params.get("no_check_flags", " ").split()
no_check_flags = set(map(utils_misc.Flag, no_check_flags))
# option_flags are generated by kernel or kvm, which are not definded in
# dump file, but can be displayed in guest
option_flags = params.get("option_flags", " ").split()
if params["smp"] == "1" and "up" not in option_flags:
option_flags.append("up")
option_flags = set(map(utils_misc.Flag, option_flags))
# add_flags are exposed by +flag
add_flags = get_extra_flag(extra_flags, "+")
# del_flags are disabled by -flag
del_flags = get_extra_flag(extra_flags, "-", lack_check=True)
expected_flags = (model_support_flags | add_flags) - del_flags - out_flags
# get all flags for host lack flag checking
check_flags = get_extra_flag(extra_flags, "+", lack_check=True)
check_flags = check_flags - no_check_flags
host_flags = set(map(utils_misc.Flag, host_flags))
lack_flags = set(expected_flags | check_flags) - host_flags
if "check" in extra_flags and "unknown" not in extra_flags:
error.context("Check lack flag in host", logging.info)
process_output = vm.process.get_output()
miss_warn = []
if lack_flags:
for flag in lack_flags:
if flag not in process_output:
miss_warn.extend(flag.split())
if miss_warn:
raise error.TestFail("no warning for lack flag %s" % miss_warn)
error.context("Compare guest flags with expected flags", logging.info)
all_support_flags = get_all_support_flags()
missing_flags = expected_flags - guest_flags
unexpect_flags = guest_flags - expected_flags - all_support_flags - option_flags
if missing_flags or unexpect_flags:
raise error.TestFail(
"missing flags:\n %s\n"
"more flags than expected:\n %s\n"
"expected flags:\n %s\n"
"guest flags:\n %s\n" % (missing_flags, unexpect_flags, expected_flags, guest_flags)
)
def run(test, params, env):
"""
flag_check test:
steps:
1. boot guest with -cpu model,+extra_flags (extra_flags is optional)
a. no defined model_name in cfg file
guest_model = host_model
b. model_name defined in cfg file
guest_model = params.get("cpu_model")
2. get guest flags
3. get expected model flags from dump file
a. -cpu host: qemu_model = host_model
b. guest_model > host_model --> expected_model = host_model
e.g guest_model = Haswell, host_model = Sandybridge
expected_model = Sandybridge
c. guest_model < host_model --> expected_model = guest_model
4. get extra flags
a. add_flags = +flag
1). flag is exposed to guest if it's supported in host
2). flag is not supported to guest if it's unknown in host
3). ignore "check", "enforce" which are params not flag
b. del_flags = -flag
flag is removed if it's supported in guest
c. params check: check lack flag in host include unknow flag
5. compare expected flag with flags in guest
a. out_flags: not supported with some conf, this kinds of flag
will be displayed in dump file, but not in guest.
e.g tsc-dedline is not supported with -M rhel6.3.0
b. option_flags: some flag is generated by kernel which is not
defined in dump file. it's acceptable when display in guest.
e.g rep_good
expected_flags = expected_model_flags + add_flags - del_flags
- out_flags
miss_flag = expected_flags - guest_flags
unexpect_flag = guest_flags - expected_flags - option_flags
:param test: Kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def qemu_model_info(models_list, cpumodel):
"""
Get cpumodel info from models_list
:param models_list: all models info
:param cpumodel: model name
:return: model info of cpumodel
"""
for model in models_list:
if cpumodel in model:
return model
return None
def qemu_support_flag(model_info, reg):
"""
Get register's supported flags from model_info
:param model_info: model_info get from dump file
:param reg: reg name, e.g feature_edx
"""
reg_re = re.compile(r".*%s.*\((.*)\)\n" % reg)
flag = reg_re.search(model_info)
try:
if flag:
return flag.groups()[0]
except Exception as e:
logging.error("Failed to get support flag %s" % e)
def get_all_support_flags():
"""
Get all supported flags with qemu query cmd.
"""
qemu_binary = utils_misc.get_qemu_binary(params)
cmd = qemu_binary + params.get("query_cmd", " -cpu ?")
output = process.system_output(cmd)
flags_re = re.compile(params.get("pattern", "flags:(.*)"))
flag_list = flags_re.search(output)
flags = []
if flag_list:
for flag in flag_list.groups():
flags += flag
return set(map(utils_misc.Flag, flags))
def get_extra_flag(extra_flags, symbol, lack_check=False):
"""
Get added/removed flags
:param extra_flags: exposed/removed flags. e.g "+sse4.1,+sse4.2"
:param symbol: "+","-"
:return: return all extra_flags if lack_check is true
return host supported flags if lack_check is false
"""
flags = []
re_flags = [_[1:] for _ in extra_flags.split(",")
if _ and symbol == _[0]]
for flag in re_flags:
if lack_check:
flags.append(flag)
elif flag in host_flags:
flags.append(flag)
return set(map(utils_misc.Flag, flags))
def get_guest_cpuflags(vm_session):
"""
Get guest system cpuflags.
:param vm_session: session to checked vm.
:return: [corespond flags]
"""
flags_re = re.compile(r'^flags\s*:(.*)$', re.MULTILINE)
out = vm_session.cmd_output("cat /proc/cpuinfo")
try:
flags = flags_re.search(out).groups()[0].split()
return set(map(utils_misc.Flag, flags))
except Exception as e:
logging.error("Failed to get guest cpu flags %s" % e)
utils_misc.Flag.aliases = utils_misc.kvm_map_flags_aliases
# Get all models' info from dump file
dump_file = params.get("dump_file")
default_dump_path = os.path.join(data_dir.get_deps_dir(), "cpuid")
dump_path = params.get("dump_path", default_dump_path)
dump_file_path = os.path.join(dump_path, dump_file)
cpuinfo_file = os.path.join(default_dump_path, dump_file)
download.get_file(dump_file_path, dump_file)
host_flags = utils_misc.get_cpu_flags()
vm = env.get_vm(params["main_vm"])
guest_cpumodel = vm.cpuinfo.model
extra_flags = params.get("cpu_model_flags", " ")
error_context.context("Boot guest with -cpu %s,%s" %
(guest_cpumodel, extra_flags), logging.info)
if params.get("start_vm") == "no" and "unknown,check" in extra_flags:
params["start_vm"] = "yes"
try:
vm.create(params=params)
vm.verify_alive()
output = vm.process.get_output()
vm.destroy()
except virt_vm.VMCreateError as detail:
output = str(detail)
if params["qemu_output"] not in output:
test.fail("no qemu output: %s" % params["qemu_output"])
else:
vm.verify_alive()
timeout = float(params.get("login_timeout", 240))
session = vm.wait_for_login(timeout=timeout)
# Get qemu model
host_cpumodel = utils_misc.get_host_cpu_models()
if guest_cpumodel not in host_cpumodel:
qemu_model = host_cpumodel[0]
else:
qemu_model = guest_cpumodel
error_context.context("Get model %s support flags" % qemu_model,
logging.info)
# Get flags for every reg from model's info
models_info = process.system_output(
"cat %s" % cpuinfo_file).split("x86")
model_info = qemu_model_info(models_info, qemu_model)
reg_list = params.get("reg_list", "feature_edx ").split()
model_support_flags = " "
if model_info:
for reg in reg_list:
reg_flags = qemu_support_flag(model_info, reg)
if reg_flags:
model_support_flags += " %s" % reg_flags
model_support_flags = set(map(utils_misc.Flag,
model_support_flags.split()))
error_context.context("Get guest flags", logging.info)
guest_flags = get_guest_cpuflags(session)
error_context.context("Get expected flag list", logging.info)
# out_flags is definded in dump file, but not in guest
out_flags = params.get("out_flags", " ").split()
out_flags = set(map(utils_misc.Flag, out_flags))
# no_check_flags is definded in all_support_flags, but not in guest and host
no_check_flags = params.get("no_check_flags", " ").split()
no_check_flags = set(map(utils_misc.Flag, no_check_flags))
# option_flags are generated by kernel or kvm, which are not definded in
# dump file, but can be displayed in guest
option_flags = params.get("option_flags", " ").split()
if params['smp'] == '1' and 'up' not in option_flags:
option_flags.append('up')
option_flags = set(map(utils_misc.Flag, option_flags))
# add_flags are exposed by +flag
add_flags = get_extra_flag(extra_flags, "+")
# del_flags are disabled by -flag
del_flags = get_extra_flag(extra_flags, "-", lack_check=True)
expected_flags = ((model_support_flags | add_flags) -
del_flags - out_flags)
# get all flags for host lack flag checking
check_flags = get_extra_flag(extra_flags, "+", lack_check=True)
check_flags = check_flags - no_check_flags
host_flags = set(map(utils_misc.Flag, host_flags))
lack_flags = set(expected_flags | check_flags) - host_flags
if "check" in extra_flags and "unknown" not in extra_flags:
error_context.context("Check lack flag in host", logging.info)
process_output = vm.process.get_output()
miss_warn = []
if lack_flags:
for flag in lack_flags:
if flag not in process_output:
miss_warn.extend(flag.split())
if miss_warn:
test.fail("no warning for lack flag %s" % miss_warn)
error_context.context("Compare guest flags with expected flags",
logging.info)
all_support_flags = get_all_support_flags()
missing_flags = expected_flags - guest_flags
unexpect_flags = (guest_flags - expected_flags -
all_support_flags - option_flags)
if missing_flags or unexpect_flags:
test.fail("missing flags:\n %s\n"
"more flags than expected:\n %s\n"
"expected flags:\n %s\n"
"guest flags:\n %s\n"
% (missing_flags, unexpect_flags, expected_flags,
guest_flags))
