def __init__(self, cpu_model, extra_flags=set([])): virtual_flags = set(map(utils_misc.Flag, params.get("guest_spec_flags", "").split())) self.hw_flags = set(map(utils_misc.Flag, params.get("host_spec_flags", "").split())) self.qemu_support_flags = get_all_qemu_flags() self.host_support_flags = set(map(utils_misc.Flag, utils_misc.get_cpu_flags())) self.quest_cpu_model_flags = (get_guest_host_cpuflags(cpu_model) - virtual_flags) self.supported_flags = (self.qemu_support_flags & self.host_support_flags) self.cpumodel_unsupport_flags = (self.supported_flags - self.quest_cpu_model_flags) self.host_unsupported_flags = (self.quest_cpu_model_flags - self.host_support_flags) self.all_possible_guest_flags = (self.quest_cpu_model_flags - self.host_unsupported_flags) self.all_possible_guest_flags |= self.cpumodel_unsupport_flags self.guest_flags = (self.quest_cpu_model_flags - self.host_unsupported_flags) self.guest_flags |= extra_flags self.host_all_unsupported_flags = set([]) self.host_all_unsupported_flags |= self.qemu_support_flags self.host_all_unsupported_flags -= (self.host_support_flags | virtual_flags)
def __init__(self, cpu_model, extra_flags=set([])): virtual_flags = set( map(utils_misc.Flag, params.get("guest_spec_flags", "").split())) self.hw_flags = set( map(utils_misc.Flag, params.get("host_spec_flags", "").split())) self.qemu_support_flags = get_all_qemu_flags() self.host_support_flags = set( map(utils_misc.Flag, utils_misc.get_cpu_flags())) self.quest_cpu_model_flags = (get_guest_host_cpuflags(cpu_model) - virtual_flags) self.supported_flags = (self.qemu_support_flags & self.host_support_flags) self.cpumodel_unsupport_flags = (self.supported_flags - self.quest_cpu_model_flags) self.host_unsupported_flags = (self.quest_cpu_model_flags - self.host_support_flags) self.all_possible_guest_flags = (self.quest_cpu_model_flags - self.host_unsupported_flags) self.all_possible_guest_flags |= self.cpumodel_unsupport_flags self.guest_flags = (self.quest_cpu_model_flags - self.host_unsupported_flags) self.guest_flags |= extra_flags self.host_all_unsupported_flags = set([]) self.host_all_unsupported_flags |= self.qemu_support_flags self.host_all_unsupported_flags -= (self.host_support_flags | virtual_flags)
def run(test, params, env): """ Qemu guest pxe boot test: 1). check npt/ept function enable, then boot vm 2). execute query/info cpus in loop 3). verify vm not paused during pxe booting params: :param test: QEMU test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ restore_mmu_cmd = None pxe_timeout = int(params.get("pxe_timeout", 60)) error_context.context("Enable ept/npt", logging.info) try: flag = list(filter(lambda x: x in utils_misc.get_cpu_flags(), ['ept', 'npt']))[0] except IndexError: logging.info("Host doesn't support ept/npt, skip the configuration") else: enable_mmu_cmd = params["enable_mmu_cmd_%s" % flag] check_mmu_cmd = params["check_mmu_cmd_%s" % flag] restore_mmu_cmd = params["restore_mmu_cmd_%s" % flag] status = process.system(check_mmu_cmd, timeout=120, ignore_status=True, shell=True) if status != 0: _kill_vms(params, env) process.run(enable_mmu_cmd, shell=True) params["start_vm"] = "yes" params["kvm_vm"] = "yes" params["paused_after_start_vm"] = "yes" error_context.context("Try to boot from NIC", logging.info) env_process.preprocess_vm(test, params, env, params["main_vm"]) vm = env.get_vm(params["main_vm"]) bg = utils_misc.InterruptedThread(_capture_tftp, (test, vm, pxe_timeout)) count = 0 try: bg.start() error_context.context("Query cpus in loop", logging.info) vm.resume() while True: count += 1 try: vm.monitor.info("cpus") vm.verify_status("running") if not bg.is_alive(): break except qemu_monitor.MonitorSocketError: test.fail("Qemu looks abnormally, please read the log") logging.info("Execute info/query cpus %d times", count) finally: bg.join() if restore_mmu_cmd: _kill_vms(params, env) process.run(restore_mmu_cmd, shell=True)
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_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 """ host_flags = utils_misc.get_cpu_flags() cpu_vendor = utils_misc.get_cpu_vendor(host_flags) host_model = utils_misc.get_cpu_model() 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.split(",")[-1]) 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.split(",")[0], model))
def run_once(self): """ Try to access different resources which are restricted by cgroup. """ logging.info('Starting cpuflags testing') def check_cpuflags_work(flags): """ Check which flags work. @param vm: Virtual machine. @param path: Path of cpuflags_test @param flags: Flags to test. @return: Tuple (Working, not working, not tested) flags. """ pass_Flags = [] not_tested = [] not_working = [] for f in flags: try: for tc in utils_misc.kvm_map_flags_to_test[f]: utils.run("./cpuflags-test --%s" % (tc)) pass_Flags.append(f) except error.CmdError: not_working.append(f) except KeyError: not_tested.append(f) return (pass_Flags, not_working, not_tested) def run_stress(timeout, flags, smp): """ Run stress on vm for timeout time. """ ret = False flags = check_cpuflags_work(flags) try: utils.run( "./cpuflags-test --stress %s%s" % (smp, utils_misc.kvm_flags_to_stresstests(flags[0])), timeout) except error.CmdError: ret = True return ret os.chdir(self.srcdir) run_stress(60, set(map(utils_misc.Flag, utils_misc.get_cpu_flags())), 4)
def run_once(self): """ Try to access different resources which are restricted by cgroup. """ logging.info('Starting cpuflags testing') def check_cpuflags_work(flags): """ Check which flags work. @param vm: Virtual machine. @param path: Path of cpuflags_test @param flags: Flags to test. @return: Tuple (Working, not working, not tested) flags. """ pass_Flags = [] not_tested = [] not_working = [] for f in flags: try: for tc in utils_misc.kvm_map_flags_to_test[f]: utils.run("./cpuflags-test --%s" % (tc)) pass_Flags.append(f) except error.CmdError: not_working.append(f) except KeyError: not_tested.append(f) return (pass_Flags, not_working, not_tested) def run_stress(timeout, flags, smp): """ Run stress on vm for timeout time. """ ret = False flags = check_cpuflags_work(flags) try: utils.run("./cpuflags-test --stress %s%s" % (smp, utils_misc.kvm_flags_to_stresstests(flags[0])), timeout) except error.CmdError: ret = True return ret os.chdir(self.srcdir) run_stress(60, set(map(utils_misc.Flag, utils_misc.get_cpu_flags())), 4)
def __init__(self, test, params, env): """ According cpu flag init module name and mmu """ self.test = test self.params = params self.env = env c_flags = utils_misc.get_cpu_flags() if 'vmx' in c_flags: name = 'kvm_intel' if 'ept' in c_flags: mmu = "ept" elif 'svm' in c_flags: name = "kvm_amd" if 'npt' in c_flags: mmu = "npt" self.mmu = mmu super(PxeTest, self).__init__(name)
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 """ host_flags = utils_misc.get_cpu_flags() cpu_vendor = utils_misc.get_cpu_vendor(host_flags) host_model = utils_misc.get_cpu_model() 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.split(",")[-1]) 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.split(",")[0], model))
def parse_qemu_cpucommand(cpumodel): """ Parse qemu cpu params. @param cpumodel: Cpu model command. @return: All flags which guest must have. """ flags = cpumodel.split(",") cpumodel = flags[0] qemu_model_flag = get_guest_host_cpuflags(cpumodel) host_support_flag = set(map(utils_misc.Flag, utils_misc.get_cpu_flags())) real_flags = qemu_model_flag & host_support_flag for f in flags[1:]: if f[0].startswith("+"): real_flags |= set([get_flags_full_name(f[1:])]) if f[0].startswith("-"): real_flags -= set([get_flags_full_name(f[1:])]) return real_flags
def parse_qemu_cpucommand(cpumodel): """ Parse qemu cpu params. :param cpumodel: Cpu model command. :return: All flags which guest must have. """ flags = cpumodel.split(",") cpumodel = flags[0] qemu_model_flag = get_guest_host_cpuflags(cpumodel) host_support_flag = set( map(utils_misc.Flag, utils_misc.get_cpu_flags())) real_flags = qemu_model_flag & host_support_flag for f in flags[1:]: if f[0].startswith("+"): real_flags |= set([get_flags_full_name(f[1:])]) if f[0].startswith("-"): real_flags -= set([get_flags_full_name(f[1:])]) return real_flags
def run_pxe_query_cpus(test, params, env): """ Qemu guest pxe boot test: 1). check npt/ept function enable, then boot vm 2). execute query/info cpus in loop 3). verify vm not paused during pxe booting params: :param test: QEMU test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ def stopVMS(params, env): """ Kill all VMS for relaod kvm_intel/kvm_amd module; """ for vm in env.get_all_vms(): if vm: vm.destroy() env.unregister_vm(vm.name) qemu_bin = os.path.basename(params["qemu_binary"]) utils.run("killall -g %s" % qemu_bin, ignore_status=True) time.sleep(5) error.context("Enable hardware MMU", logging.info) enable_mmu_cmd = check_mmu_cmd = restore_mmu_cmd = None try: flag = filter(lambda x: x in utils_misc.get_cpu_flags(), ['ept', 'npt'])[0] except IndexError: logging.warn("Host doesn't support Hareware MMU") else: enable_mmu_cmd = params["enable_mmu_cmd_%s" % flag] check_mmu_cmd = params["check_mmu_cmd_%s" % flag] status = utils.system(check_mmu_cmd, timeout=120, ignore_status=True) if status != 0: stopVMS(params, env) utils.run(enable_mmu_cmd) restore_mmu_cmd = params["restore_mmu_cmd_%s" % flag] params["start_vm"] = "yes" params["kvm_vm"] = "yes" params["restart_vm"] = "no" env_process.preprocess_vm(test, params, env, params["main_vm"]) vm = env.get_vm(params["main_vm"]) bg = utils.InterruptedThread(utils_test.run_virt_sub_test, args=(test, params, env,), kwargs={"sub_type": "pxe"}) bg.start() count = 0 try: error.context("Query cpus in loop", logging.info) while True: vm.monitor.info("cpus") count += 1 vm.verify_status("running") if not bg.isAlive(): break logging.info("Execute info/query cpus %d times", count) finally: if restore_mmu_cmd: stopVMS(params, env) utils.run(restore_mmu_cmd)
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))
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): """ Qemu guest pxe boot test: 1). check npt/ept function enable, then boot vm 2). execute query/info cpus in loop 3). verify vm not paused during pxe booting params: :param test: QEMU test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ restore_mmu_cmd = None pxe_timeout = int(params.get("pxe_timeout", 60)) error_context.context("Enable ept/npt", logging.info) try: flag = list( filter(lambda x: x in utils_misc.get_cpu_flags(), ['ept', 'npt']))[0] except IndexError: logging.info("Host doesn't support ept/npt, skip the configuration") else: enable_mmu_cmd = params["enable_mmu_cmd_%s" % flag] check_mmu_cmd = params["check_mmu_cmd_%s" % flag] restore_mmu_cmd = params["restore_mmu_cmd_%s" % flag] status = process.system(check_mmu_cmd, timeout=120, ignore_status=True, shell=True) if status != 0: _kill_vms(params, env) process.run(enable_mmu_cmd, shell=True) params["start_vm"] = "yes" params["kvm_vm"] = "yes" params["paused_after_start_vm"] = "yes" error_context.context("Try to boot from NIC", logging.info) env_process.preprocess_vm(test, params, env, params["main_vm"]) vm = env.get_vm(params["main_vm"]) bg = utils_misc.InterruptedThread(_capture_tftp, (test, vm, pxe_timeout)) count = 0 try: bg.start() error_context.context("Query cpus in loop", logging.info) vm.resume() while True: count += 1 try: vm.monitor.info("cpus") vm.verify_status("running") if not bg.is_alive(): break except qemu_monitor.MonitorSocketError: test.fail("Qemu looks abnormally, please read the log") logging.info("Execute info/query cpus %d times", count) finally: bg.join() if restore_mmu_cmd: _kill_vms(params, env) process.run(restore_mmu_cmd, shell=True)
def run(test, params, env): """ Qemu guest pxe boot test: 1). check npt/ept function enable, then boot vm 2). execute query/info cpus in loop 3). verify vm not paused during pxe booting params: :param test: QEMU test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ def stopVMS(params, env): """ Kill all VMS for relaod kvm_intel/kvm_amd module; """ for vm in env.get_all_vms(): if vm: vm.destroy() env.unregister_vm(vm.name) qemu_bin = os.path.basename(params["qemu_binary"]) process.run("killall -g %s" % qemu_bin, ignore_status=True) time.sleep(5) enable_mmu_cmd = None check_mmu_cmd = None restore_mmu_cmd = None error_context.context("Enable ept(npt)", logging.info) try: flag = list(filter(lambda x: x in utils_misc.get_cpu_flags(), ['ept', 'npt']))[0] except IndexError: logging.warn("Host doesn't support ept(npt)") else: enable_mmu_cmd = params["enable_mmu_cmd_%s" % flag] check_mmu_cmd = params["check_mmu_cmd_%s" % flag] status = process.system(check_mmu_cmd, timeout=120, ignore_status=True, shell=True) if status != 0: stopVMS(params, env) process.run(enable_mmu_cmd, shell=True) restore_mmu_cmd = params["restore_mmu_cmd_%s" % flag] params["start_vm"] = "yes" params["kvm_vm"] = "yes" params["paused_after_start_vm"] = "yes" env_process.preprocess_vm(test, params, env, params["main_vm"]) bg = utils_misc.InterruptedThread(utils_test.run_virt_sub_test, args=(test, params, env,), kwargs={"sub_type": "pxe_boot"}) count = 0 try: bg.start() error_context.context("Query cpus in loop", logging.info) vm = env.get_vm(params["main_vm"]) vm.resume() while True: count += 1 try: vm.monitor.info("cpus") vm.verify_status("running") if not bg.is_alive(): break except qemu_monitor.MonitorSocketError: test.fail("Qemu looks abnormally, please read the log") logging.info("Execute info/query cpus %d times", count) finally: bg.join() if restore_mmu_cmd: stopVMS(params, env) process.run(restore_mmu_cmd, shell=True)
def run(test, params, env): """ Qemu guest pxe boot test: 1). check npt/ept function enable, then boot vm 2). execute query/info cpus in loop 3). verify vm not paused during pxe booting params: :param test: QEMU test object :param params: Dictionary with the test parameters :param env: Dictionary with test environment. """ def stopVMS(params, env): """ Kill all VMS for relaod kvm_intel/kvm_amd module; """ for vm in env.get_all_vms(): if vm: vm.destroy() env.unregister_vm(vm.name) qemu_bin = os.path.basename(params["qemu_binary"]) utils.run("killall -g %s" % qemu_bin, ignore_status=True) time.sleep(5) error.context("Enable hardware MMU", logging.info) enable_mmu_cmd = check_mmu_cmd = restore_mmu_cmd = None try: flag = filter(lambda x: x in utils_misc.get_cpu_flags(), ['ept', 'npt'])[0] except IndexError: logging.warn("Host doesn't support Hareware MMU") else: enable_mmu_cmd = params["enable_mmu_cmd_%s" % flag] check_mmu_cmd = params["check_mmu_cmd_%s" % flag] status = utils.system(check_mmu_cmd, timeout=120, ignore_status=True) if status != 0: stopVMS(params, env) utils.run(enable_mmu_cmd) restore_mmu_cmd = params["restore_mmu_cmd_%s" % flag] params["start_vm"] = "yes" params["kvm_vm"] = "yes" env_process.preprocess_vm(test, params, env, params["main_vm"]) vm = env.get_vm(params["main_vm"]) bg = utils.InterruptedThread(utils_test.run_virt_sub_test, args=( test, params, env, ), kwargs={"sub_type": "pxe"}) bg.start() count = 0 try: error.context("Query cpus in loop", logging.info) while True: vm.monitor.info("cpus") count += 1 vm.verify_status("running") if not bg.isAlive(): break logging.info("Execute info/query cpus %d times", count) finally: if restore_mmu_cmd: stopVMS(params, env) utils.run(restore_mmu_cmd)
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, 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) 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]