def run(test, params, env):
"""
KVM guest stop test:
1) Log into a guest
2) Check is fio.msi installed, install it if not installed.
3) Start fio test on both sys and data disk in guest
4) Get the result
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
install_path = params["install_path"].rstrip("\\")
fio_log_file = params.get("fio_log_file")
fio_cmd = params.get("fio_cmd")
timeout = float(params.get("login_timeout", 360))
cmd_timeout = int(params.get("cmd_timeout", "360"))
check_installed_cmd = 'dir "%s"|findstr /I fio' % install_path
check_installed_cmd = params.get("check_installed_cmd",
check_installed_cmd)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=timeout)
if not params.get('image_backend') == 'nvme_direct':
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session,
params["disk_index"],
mountpoint=params["disk_letter"])
try:
installed = session.cmd_status(check_installed_cmd) == 0
if not installed:
dst = r"%s:\\" % utils_misc.get_winutils_vol(session)
error_context.context("Install fio in guest", logging.info)
install_cmd = params["install_cmd"]
install_cmd = re.sub(r"DRIVE:\\+", dst, install_cmd)
session.cmd(install_cmd, timeout=180)
time.sleep(30)
config_cmd = params.get("config_cmd")
if config_cmd:
session.cmd(config_cmd)
error_context.context("Start fio in guest.", logging.info)
status, output = session.cmd_status_output(fio_cmd,
timeout=(cmd_timeout * 2))
if status:
test.error("Failed to run fio, output: %s" % output)
finally:
error_context.context("Copy fio log from guest to host.", logging.info)
try:
vm.copy_files_from(fio_log_file, test.resultsdir)
except Exception as err:
logging.warn("Log file copy failed: %s", err)
if session:
session.close()
def run(test, params, env):
"""
KVM guest stop test:
1) Log into a guest
2) Check is fio.msi installed, install it if not installed.
3) Start fio test on both sys and data disk in guest
4) Get the result
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
install_path = params["install_path"].rstrip("\\")
fio_log_file = params.get("fio_log_file")
fio_cmd = params.get("fio_cmd")
timeout = float(params.get("login_timeout", 360))
cmd_timeout = int(params.get("cmd_timeout", "360"))
check_installed_cmd = 'dir "%s"|findstr /I fio' % install_path
check_installed_cmd = params.get("check_installed_cmd",
check_installed_cmd)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=timeout)
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session, params["disk_index"],
mountpoint=params["disk_letter"])
try:
installed = session.cmd_status(check_installed_cmd) == 0
if not installed:
dst = r"%s:\\" % utils_misc.get_winutils_vol(session)
error_context.context("Install fio in guest", logging.info)
install_cmd = params["install_cmd"]
install_cmd = re.sub(r"DRIVE:\\+", dst, install_cmd)
session.cmd(install_cmd, timeout=180)
time.sleep(30)
config_cmd = params.get("config_cmd")
if config_cmd:
session.cmd(config_cmd)
error_context.context("Start fio in guest.", logging.info)
status, output = session.cmd_status_output(fio_cmd, timeout=(cmd_timeout*2))
if status:
test.error("Failed to run fio, output: %s" % output)
finally:
error_context.context("Copy fio log from guest to host.", logging.info)
try:
vm.copy_files_from(fio_log_file, test.resultsdir)
except Exception as err:
logging.warn("Log file copy failed: %s" % err)
if session:
session.close()
def format_multi_disks():
disk_letters = params["disk_letters"].split()
disk_indexes = params["disk_indexes"].split()
disk_fstypes = params["disk_fstypes"].split()
error_context.context("Format the multiple disks.", test.log.info)
for index, letter, fstype in zip(disk_indexes, disk_letters,
disk_fstypes):
utils_misc.format_windows_disk(session,
index,
letter,
fstype=fstype)
def format_disk_win():
""" Format disk in windows. """
error_context.context("Format disk %s in windows." % new_disk,
logging.info)
session = vm.wait_for_login(timeout=timeout)
if disk_index is None and disk_letter is None:
drive_letters.append(
utils_disk.configure_empty_windows_disk(
session, new_disk, params['image_size_%s' % img])[0])
elif disk_index and disk_letter:
utils_misc.format_windows_disk(session, disk_index[index],
disk_letter[index])
drive_letters.append(disk_letter[index])
session.close()
def run(test, params, env):
"""
KVM guest stop test:
1) Log into a guest
2) Check is fio.msi installed, install it if not installed.
3) Start fio test on both sys and data disk in guest
4) Get the result
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
install_path = params["install_path"].rstrip("\\")
fio_log_file = params.objects("fio_log_file")
fio_file_name = params.objects("fio_file_name")
fio_cmd_sys = params.get("fio_cmd") % (fio_file_name[0], "sys",
fio_log_file[0])
fio_cmd_data = params.get("fio_cmd") % (fio_file_name[1], "data",
fio_log_file[1])
timeout = float(params.get("login_timeout", 360))
cmd_timeout = int(params.get("cmd_timeout", "360"))
check_installed_cmd = 'dir "%s"|findstr /I fio' % install_path
check_installed_cmd = params.get("check_installed_cmd",
check_installed_cmd)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session_sys = vm.wait_for_login(timeout=timeout)
session_data = vm.wait_for_login(timeout=timeout)
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session_sys,
params["disk_index"],
mountpoint=params["disk_letter"])
try:
installed = session_sys.cmd_status(check_installed_cmd) == 0
if not installed:
dst = r"%s:\\" % utils_misc.get_winutils_vol(session_sys)
error_context.context("Install fio in guest", logging.info)
install_cmd = params["install_cmd"]
install_cmd = re.sub(r"DRIVE:\\+", dst, install_cmd)
session_sys.cmd(install_cmd, timeout=180)
time.sleep(30)
config_cmd = params.get("config_cmd")
if config_cmd:
session_sys.cmd(config_cmd)
error_context.context("Start fio in guest.", logging.info)
# FIXME:Here use the timeout=(cmd_timeout*2)
# Will determine a better specific calculation later
fio_thread_data = utils_misc.InterruptedThread(
session_data.cmd_status_output, (fio_cmd_data, (cmd_timeout * 2)))
fio_thread_data.start()
status_sys, output_sys = session_sys.cmd_status_output(
fio_cmd_sys, timeout=(cmd_timeout * 2))
status_data, output_data = fio_thread_data.join()
if status_sys or status_data:
test.error("Failed to run fio, output: %s\n%s" %
(output_sys, output_data))
finally:
error_context.context("Copy fio log from guest to host.", logging.info)
try:
vm.copy_files_from(fio_log_file[0], test.resultsdir)
vm.copy_files_from(fio_log_file[1], test.resultsdir)
except Exception, err:
logging.warn("Log file copy failed: %s" % err)
session_data.close()
if session_sys:
session_sys.close()
if params.get("need_enable_verifier", "no") == "yes":
error_context.context("Enable %s driver verifier" % driver_name,
logging.info)
try:
session = utils_test.qemu.setup_win_driver_verifier(
session, driver_name, vm, timeout)
funcatexit.register(env, params.get("type"),
utils_test.qemu.clear_win_driver_verifier,
session, vm, timeout)
except Exception, e:
raise exceptions.TestFail(e)
if params.get("format_disk", "no") == "yes":
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session,
disk_index,
mountpoint=disk_letter)
winutils = utils_misc.get_winutils_vol(session)
cmd = params["iozone_cmd"]
iozone_cmd = re.sub("WIN_UTILS", winutils, cmd)
error_context.context(
"Running IOzone command on guest, timeout %ss" % iozone_timeout,
logging.info)
status, results = session.cmd_status_output(cmd=iozone_cmd,
timeout=iozone_timeout)
error_context.context("Write results to %s" % results_path, logging.info)
if status != 0:
raise exceptions.TestFail("iozone test failed: %s" % results)
utils.open_write_close(results_path, results)
if driver_name:
if params.get("need_enable_verifier", "no") == "yes":
error_context.context("Enable %s driver verifier" % driver_name,
logging.info)
try:
session = utils_test.qemu.setup_win_driver_verifier(
session, driver_name, vm, timeout)
funcatexit.register(env, params.get("type"),
utils_test.qemu.clear_win_driver_verifier,
session, vm, timeout)
except Exception, e:
raise exceptions.TestFail(e)
if params.get("format_disk", "no") == "yes":
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session, disk_index,
mountpoint=disk_letter)
winutils = utils_misc.get_winutils_vol(session)
cmd = params["iozone_cmd"]
iozone_cmd = re.sub("WIN_UTILS", winutils, cmd)
error_context.context("Running IOzone command on guest, timeout %ss"
% iozone_timeout, logging.info)
status, results = session.cmd_status_output(cmd=iozone_cmd,
timeout=iozone_timeout)
error_context.context("Write results to %s" % results_path, logging.info)
if status != 0:
raise exceptions.TestFail("iozone test failed: %s" % results)
utils.open_write_close(results_path, results)
if params.get("post_result", "no") == "yes":
error_context.context("Generate graph of test result", logging.info)
def run(test, params, env):
"""
Run IOzone for windows on a windows guest:
1) Log into a guest
2) Execute the IOzone test contained in the winutils.iso
3) Get results
4) Postprocess it with the IOzone postprocessing module
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def post_result(results_path, analysisdir):
"""
Pick results from an IOzone run, generate a series graphs
:params results_path: iozone test result path
:params analysisdir: output of analysis result
"""
a = postprocess_iozone.IOzoneAnalyzer(list_files=[results_path],
output_dir=analysisdir)
a.analyze()
p = postprocess_iozone.IOzonePlotter(results_file=results_path,
output_dir=analysisdir)
p.plot_all()
def get_driver():
"""
Get driver name
"""
driver_name = params.get("driver_name", "")
drive_format = params.get("drive_format")
if not driver_name:
if "scsi" in drive_format:
driver_name = "vioscsi"
elif "virtio" in drive_format:
driver_name = "viostor"
else:
driver_name = None
return driver_name
def run_iozone_parallel(timeout):
""" Run the iozone parallel. """
iozone_sessions = []
iozone_threads = []
thread_maps = {}
for _ in disk_letters:
iozone_sessions.append(vm.wait_for_login(timeout=360))
for iozone_session, disk_letter in zip(iozone_sessions, disk_letters):
args = (iozone_cmd.format(disk_letter), iozone_timeout)
thread_maps[disk_letter] = (iozone_session.cmd, args)
iozone_thread = utils_misc.InterruptedThread(
iozone_session.cmd, args)
iozone_thread.setName(disk_letter)
iozone_threads.append(iozone_thread)
iozone_thread.start()
start_time = time.time()
while time.time() - start_time <= timeout:
for iozone_thread in iozone_threads:
if iozone_thread.is_alive():
continue
else:
thread_name = iozone_thread.getName()
iozone_threads.remove(iozone_thread)
iozone_threads.append(
utils_misc.InterruptedThread(
thread_maps[thread_name][0],
thread_maps[thread_name][1]))
iozone_threads[-1].setName(thread_name)
iozone_threads[-1].start()
for iozone_thread in iozone_threads:
iozone_thread.join()
test.log.info('All the iozone threads are done.')
def check_gpt_labletype(disk_index):
"""
Check the disk is gpt labletype.
"""
cmd = "echo list disk > {0} && diskpart /s {0} && del {0}"
pattern = r'Disk %s.+?B.{8}\*' % disk_index
return re.search(pattern, session.cmd_output(cmd.format("test.dp")))
timeout = int(params.get("login_timeout", 360))
iozone_timeout = int(params.get("iozone_timeout"))
disk_letters = params.get("disk_letter", 'C').split()
disk_indexes = params.get("disk_index", "2").split()
disk_fstypes = params.get("disk_fstype", "ntfs").split()
labletype = params.get("labletype", "msdos")
results_path = os.path.join(test.resultsdir,
'raw_output_%s' % test.iteration)
analysisdir = os.path.join(test.resultsdir, 'analysis_%s' % test.iteration)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=timeout)
driver_name = get_driver()
if driver_name:
session = utils_test.qemu.windrv_check_running_verifier(
session, vm, test, driver_name, timeout)
if params.get("format_disk", "no") == "yes":
for index, letter, fstype in zip(disk_indexes, disk_letters,
disk_fstypes):
orig_letters = utils_disk.get_drive_letters(session, index)
if orig_letters:
orig_letter = orig_letters[0]
if orig_letter != letter:
test.log.info("Change the drive letter from %s to %s",
orig_letter, letter)
utils_disk.drop_drive_letter(session, orig_letter)
utils_disk.set_drive_letter(session,
index,
target_letter=letter)
else:
error_context.context("Format disk", test.log.info)
utils_misc.format_windows_disk(session,
index,
letter,
fstype=fstype,
labletype=labletype)
if params.get("gpt_check", "no") == "yes":
if not check_gpt_labletype(disk_indexes[0]):
test.fail("Disk labletype is not gpt")
cmd = params["iozone_cmd"]
iozone_cmd = utils_misc.set_winutils_letter(session, cmd)
error_context.context(
"Running IOzone command on guest, timeout %ss" % iozone_timeout,
test.log.info)
if params.get('run_iozone_parallel', 'no') == 'yes':
disk_letters.append('C')
run_iozone_parallel(int(params['stress_timeout']))
return
status, results = session.cmd_status_output(cmd=iozone_cmd,
timeout=iozone_timeout)
error_context.context("Write results to %s" % results_path, test.log.info)
if status != 0:
test.fail("iozone test failed: %s" % results)
with open(results_path, 'w') as file:
file.write(results)
if params.get("post_result", "no") == "yes":
error_context.context("Generate graph of test result", test.log.info)
post_result(results_path, analysisdir)
def run(test, params, env):
"""
KVM block resize test:
1) Start guest with data image and check the data image size.
2) Enlarge(or Decrease) the data image and check it in guest.
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def get_block_size(session, block_cmd, block_pattern):
"""
Get block size inside guest.
"""
output = session.cmd_output(block_cmd)
block_size = re.findall(block_pattern, output)
if block_size:
if not re.search("[a-zA-Z]", block_size[0]):
return int(block_size[0])
else:
return float(
utils_misc.normalize_data_size(block_size[0],
order_magnitude="B"))
else:
raise error.TestError("Can not find the block size for the"
" deivce. The output of command"
" is: %s" % output)
def compare_block_size(session, block_cmd, block_pattern):
"""
Compare the current block size with the expected size.
"""
global current_size
current_size = get_block_size(session, block_size_cmd,
block_size_pattern)
if (current_size <= block_size
and current_size >= block_size * (1 - accept_ratio)):
logging.info(
"Block Resizing Finished !!! \n"
"Current size %s is same as the expected %s", current_size,
block_size)
return True
return
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
timeout = float(params.get("login_timeout", 240))
driver_name = params.get("driver_name")
if params.get("os_type") == "windows":
utils_test.qemu.setup_win_driver_verifier(driver_name, vm, timeout)
session = vm.wait_for_login(timeout=timeout)
data_image = params.get("images").split()[-1]
data_image_params = params.object_params(data_image)
data_image_size = data_image_params.get("image_size")
data_image_size = float(
utils_misc.normalize_data_size(data_image_size, order_magnitude="B"))
data_image_filename = storage.get_image_filename(data_image_params,
data_dir.get_data_dir())
data_image_dev = vm.get_block({'file': data_image_filename})
drive_path = ""
if params.get("os_type") == 'linux':
drive_id = params["blk_extra_params_%s" % data_image].split("=")[1]
drive_path = utils_misc.get_linux_drive_path(session, drive_id)
if not drive_path:
raise error.TestError("Failed to get '%s' drive path" % data_image)
block_size_cmd = params["block_size_cmd"].format(drive_path)
block_size_pattern = params.get("block_size_pattern")
need_reboot = params.get("need_reboot", "no") == "yes"
accept_ratio = float(params.get("accept_ratio", 0))
error.context("Check image size in guest", logging.info)
block_size = get_block_size(session, block_size_cmd, block_size_pattern)
if (block_size > data_image_size
or block_size < data_image_size * (1 - accept_ratio)):
raise error.TestError("Image size from guest and image not match"
"Block size get from guest: %s \n"
"Image size get from image: %s \n" %
(block_size, data_image_size))
if params.get("guest_prepare_cmd"):
session.cmd(params.get("guest_prepare_cmd"))
if params.get("format_disk", "no") == "yes":
error.context("Format disk", logging.info)
utils_misc.format_windows_disk(session,
params["disk_index"],
mountpoint=params["disk_letter"])
disk_update_cmd = params.get("disk_update_cmd")
if disk_update_cmd:
disk_update_cmd = disk_update_cmd.split("::")
disk_rescan_cmd = params.get("disk_rescan_cmd")
block_size = data_image_size
disk_change_ratio = params["disk_change_ratio"]
for index, ratio in enumerate(disk_change_ratio.strip().split()):
old_block_size = block_size
block_size = int(int(data_image_size) * float(ratio))
if block_size == old_block_size:
logging.warn("Block size is not changed in round %s."
" Just skip it" % index)
continue
if disk_update_cmd:
if "DISK_CHANGE_SIZE" in disk_update_cmd[index]:
disk_unit = params.get("disk_unit", "M")
size = abs(block_size - old_block_size)
change_size = utils_misc.normalize_data_size(
"%sB" % size, disk_unit)
disk_update_cmd[index] = re.sub("DISK_CHANGE_SIZE",
change_size.split(".")[0],
disk_update_cmd[index])
# So far only virtio drivers support online auto block size change in
# linux guest. So we need manully update the the disk or even reboot
# guest to get the right block size after change it from monitor.
# We need shrink the disk in guest first, than in monitor
if block_size < old_block_size and disk_update_cmd:
error.context("Shrink disk size to %s in guest" % block_size,
logging.info)
session.cmd(disk_update_cmd[index])
error.context("Change disk size to %s in monitor" % block_size,
logging.info)
vm.monitor.block_resize(data_image_dev, block_size)
if need_reboot:
session = vm.reboot(session=session)
elif disk_rescan_cmd:
error.context("Rescan disk", logging.info)
session.cmd(disk_rescan_cmd)
# We need expand disk in monitor first than extend it in guest
if block_size > old_block_size and disk_update_cmd:
error.context("Extend disk to %s in guest" % block_size,
logging.info)
session.cmd(disk_update_cmd[index])
global current_size
current_size = 0
if not utils_misc.wait_for(
lambda: compare_block_size(session, block_size_cmd,
block_size_pattern), 20, 0, 1,
"Block Resizing"):
raise error.TestFail("Block size get from guest is not"
"the same as expected \n"
"Reported: %s\n"
"Expect: %s\n" % (current_size, block_size))
def run(test, params, env):
"""
Test multi disk suport of guest, this case will:
1) Create disks image in configuration file.
2) Start the guest with those disks.
3) Checks qtree vs. test params. (Optional)
4) Create partition on those disks.
5) Get disk dev filenames in guest.
6) Format those disks in guest.
7) Copy file into / out of those disks.
8) Compare the original file and the copied file using md5 or fc comand.
9) Repeat steps 3-5 if needed.
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def _add_param(name, value):
""" Converts name+value to stg_params string """
if value:
value = re.sub(' ', '\\ ', value)
return " %s:%s " % (name, value)
else:
return ''
def _do_post_cmd(session):
cmd = params.get("post_cmd")
if cmd:
session.cmd_status_output(cmd)
session.close()
def _get_disk_index(session, image_size, disk_indexs):
list_disk_cmd = "echo list disk > disk && "
list_disk_cmd += "echo exit >> disk && diskpart /s disk"
disks = session.cmd_output(list_disk_cmd)
size_type = image_size[-1] + "B"
disk_size = ""
if size_type == "MB":
disk_size = image_size[:-1] + " MB"
elif size_type == "GB" and int(image_size[:-1]) < 8:
disk_size = str(int(image_size[:-1]) * 1024) + " MB"
else:
disk_size = image_size[:-1] + " GB"
regex_str = 'Disk (\d+).*?%s.*?%s' % (disk_size, disk_size)
for disk in disks.splitlines():
if disk.startswith(" Disk"):
o = re.findall(regex_str, disk, re.I | re.M)
if o:
disk_indexs.append(o[0])
error.context("Parsing test configuration", logging.info)
stg_image_num = 0
stg_params = params.get("stg_params", "")
# Compatibility
stg_params += _add_param("image_size", params.get("stg_image_size"))
stg_params += _add_param("image_format", params.get("stg_image_format"))
stg_params += _add_param("image_boot", params.get("stg_image_boot", "no"))
stg_params += _add_param("drive_format", params.get("stg_drive_format"))
stg_params += _add_param("drive_cache", params.get("stg_drive_cache"))
if params.get("stg_assign_index") != "no":
# Assume 0 and 1 are already occupied (hd0 and cdrom)
stg_params += _add_param("drive_index", 'range(2,n)')
param_matrix = {}
stg_params = stg_params.split(' ')
i = 0
while i < len(stg_params) - 1:
if not stg_params[i].strip():
i += 1
continue
if stg_params[i][-1] == '\\':
stg_params[i] = '%s %s' % (stg_params[i][:-1],
stg_params.pop(i + 1))
i += 1
rerange = []
has_name = False
for i in xrange(len(stg_params)):
if not stg_params[i].strip():
continue
(cmd, parm) = stg_params[i].split(':', 1)
if cmd == "image_name":
has_name = True
if _RE_RANGE1.match(parm):
parm = _range(parm)
if parm is False:
raise error.TestError("Incorrect cfg: stg_params %s looks "
"like range(..) but doesn't contain "
"numbers." % cmd)
param_matrix[cmd] = parm
if type(parm) is str:
# When we know the stg_image_num, substitute it.
rerange.append(cmd)
continue
else:
# ',' separated list of values
parm = parm.split(',')
j = 0
while j < len(parm) - 1:
if parm[j][-1] == '\\':
parm[j] = '%s,%s' % (parm[j][:-1], parm.pop(j + 1))
j += 1
param_matrix[cmd] = parm
stg_image_num = max(stg_image_num, len(parm))
stg_image_num = int(params.get('stg_image_num', stg_image_num))
for cmd in rerange:
param_matrix[cmd] = _range(param_matrix[cmd], stg_image_num)
# param_table* are for pretty print of param_matrix
param_table = []
param_table_header = ['name']
if not has_name:
param_table_header.append('image_name')
for _ in param_matrix:
param_table_header.append(_)
stg_image_name = params.get('stg_image_name', 'images/%s')
for i in xrange(stg_image_num):
name = "stg%d" % i
params['images'] += " %s" % name
param_table.append([])
param_table[-1].append(name)
if not has_name:
params["image_name_%s" % name] = stg_image_name % name
param_table[-1].append(params.get("image_name_%s" % name))
for parm in param_matrix.iteritems():
params['%s_%s' % (parm[0], name)] = str(parm[1][i % len(parm[1])])
param_table[-1].append(params.get('%s_%s' % (parm[0], name)))
if params.get("multi_disk_params_only") == 'yes':
# Only print the test param_matrix and finish
logging.info('Newly added disks:\n%s',
utils.matrix_to_string(param_table, param_table_header))
return
# Always recreate VMs and disks
error.context("Start the guest with new disks", logging.info)
for vm_name in params.objects("vms"):
vm_params = params.object_params(vm_name)
env_process.process_images(env_process.preprocess_image, test,
vm_params)
error.context("Start the guest with those disks", logging.info)
vm = env.get_vm(params["main_vm"])
vm.create(timeout=max(10, stg_image_num), params=params)
session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
n_repeat = int(params.get("n_repeat", "1"))
file_system = [_.strip() for _ in params.get("file_system").split()]
cmd_timeout = float(params.get("cmd_timeout", 360))
re_str = params["re_str"]
black_list = params["black_list"].split()
os_type = params["os_type"]
stg_image_size = params.get("stg_image_size")
disk_indexs = []
have_qtree = True
out = vm.monitor.human_monitor_cmd("info qtree", debug=False)
if "unknown command" in str(out):
have_qtree = False
if (params.get("check_guest_proc_scsi") == "yes") and have_qtree:
error.context("Verifying qtree vs. test params")
err = 0
qtree = qemu_qtree.QtreeContainer()
qtree.parse_info_qtree(vm.monitor.info('qtree'))
disks = qemu_qtree.QtreeDisksContainer(qtree.get_nodes())
(tmp1, tmp2) = disks.parse_info_block(vm.monitor.info_block())
err += tmp1 + tmp2
err += disks.generate_params()
err += disks.check_disk_params(params)
(tmp1, tmp2, _, _) = disks.check_guests_proc_scsi(
session.cmd_output('cat /proc/scsi/scsi'))
err += tmp1 + tmp2
if err:
raise error.TestFail("%s errors occurred while verifying"
" qtree vs. params" % err)
if params.get('multi_disk_only_qtree') == 'yes':
return
try:
cmd = params.get("clean_cmd")
if cmd:
session.cmd_status_output(cmd)
if params.get("os_type") == "windows":
error.context("Create partition on those disks", logging.info)
# Get the disk index
_get_disk_index(session, stg_image_size, disk_indexs)
# Random select one file system from file_system
index = random.randint(0, (len(file_system) - 1))
fs_type = file_system[index].strip()
for i in xrange(stg_image_num):
utils_misc.format_windows_disk(session, disk_indexs[i], None,
None, fs_type)
error.context("Get disks dev filenames in guest", logging.info)
cmd = params["list_volume_command"]
s, output = session.cmd_status_output(cmd, timeout=cmd_timeout)
if s != 0:
raise error.TestFail("List volume command failed with cmd '%s'.\n"
"Output is: %s\n" % (cmd, output))
output = session.cmd_output(cmd, timeout=cmd_timeout)
disks = re.findall(re_str, output)
disks = map(string.strip, disks)
disks.sort()
logging.debug("Volume list that meet regular expressions: %s",
" ".join(disks))
images = params.get("images").split()
if len(disks) < len(images):
logging.debug("disks: %s , images: %s", len(disks), len(images))
raise error.TestFail("Fail to list all the volumes!")
if params.get("os_type") == "linux":
output = session.cmd_output("mount")
li = re.findall(r"^/dev/(%s)\d*" % re_str, output, re.M)
if li:
black_list.extend(li)
else:
black_list.extend(utils_misc.get_winutils_vol(session))
disks = set(disks)
black_list = set(black_list)
logging.info("No need to check volume '%s'", (disks & black_list))
disks = disks - black_list
except Exception:
_do_post_cmd(session)
raise
try:
for i in range(n_repeat):
logging.info("iterations: %s", (i + 1))
error.context("Format those disks in guest", logging.info)
for disk in disks:
disk = disk.strip()
error.context("Preparing disk: %s..." % disk)
# Random select one file system from file_system
index = random.randint(0, (len(file_system) - 1))
fs = file_system[index].strip()
cmd = params["format_command"] % (fs, disk)
error.context("formatting test disk")
session.cmd(cmd, timeout=cmd_timeout)
cmd = params.get("mount_command")
if cmd:
cmd = cmd % (disk, disk, disk)
session.cmd(cmd)
error.context("Cope file into / out of those disks", logging.info)
for disk in disks:
disk = disk.strip()
error.context("Performing I/O on disk: %s..." % disk)
cmd_list = params["cmd_list"].split()
for cmd_l in cmd_list:
cmd = params.get(cmd_l)
if cmd:
session.cmd(cmd % disk, timeout=cmd_timeout)
cmd = params["compare_command"]
key_word = params["check_result_key_word"]
output = session.cmd_output(cmd)
if key_word not in output:
raise error.TestFail("Files on guest os root fs and disk "
"differ")
if params.get("umount_command"):
cmd = params.get("show_mount_cmd")
output = session.cmd_output(cmd)
disks = re.findall(re_str, output)
disks.sort()
for disk in disks:
disk = disk.strip()
error.context("Unmounting disk: %s..." % disk)
cmd = params.get("umount_command") % (disk, disk)
session.cmd(cmd)
finally:
cmd = params.get("show_mount_cmd")
if cmd:
try:
output = session.cmd_output(cmd)
disks = re.findall(re_str, output)
disks.sort()
for disk in disks:
error.context("Unmounting disk: %s..." % disk)
cmd = params["umount_command"] % (disk, disk)
session.cmd(cmd)
except Exception, err:
logging.warn("Get error when cleanup, '%s'", err)
_do_post_cmd(session)
session.close()
def run(test, params, env):
"""
Test multi disk suport of guest, this case will:
1) Create disks image in configuration file.
2) Start the guest with those disks.
3) Checks qtree vs. test params. (Optional)
4) Create partition on those disks.
5) Get disk dev filenames in guest.
6) Format those disks in guest.
7) Copy file into / out of those disks.
8) Compare the original file and the copied file using md5 or fc comand.
9) Repeat steps 3-5 if needed.
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def _add_param(name, value):
""" Converts name+value to stg_params string """
if value:
value = re.sub(' ', '\\ ', value)
return " %s:%s " % (name, value)
else:
return ''
def _do_post_cmd(session):
cmd = params.get("post_cmd")
if cmd:
session.cmd_status_output(cmd)
session.close()
def _get_disk_index(session, image_size, disk_indexs):
list_disk_cmd = "echo list disk > disk && "
list_disk_cmd += "echo exit >> disk && diskpart /s disk"
disks = session.cmd_output(list_disk_cmd)
size_type = image_size[-1] + "B"
disk_size = ""
if size_type == "MB":
disk_size = image_size[:-1] + " MB"
elif size_type == "GB" and int(image_size[:-1]) < 8:
disk_size = str(int(image_size[:-1])*1024) + " MB"
else:
disk_size = image_size[:-1] + " GB"
regex_str = 'Disk (\d+).*?%s.*?%s' % (disk_size, disk_size)
for disk in disks.splitlines():
if disk.startswith(" Disk"):
o = re.findall(regex_str, disk, re.I | re.M)
if o:
disk_indexs.append(o[0])
error.context("Parsing test configuration", logging.info)
stg_image_num = 0
stg_params = params.get("stg_params", "")
# Compatibility
stg_params += _add_param("image_size", params.get("stg_image_size"))
stg_params += _add_param("image_format", params.get("stg_image_format"))
stg_params += _add_param("image_boot", params.get("stg_image_boot", "no"))
stg_params += _add_param("drive_format", params.get("stg_drive_format"))
stg_params += _add_param("drive_cache", params.get("stg_drive_cache"))
if params.get("stg_assign_index") != "no":
# Assume 0 and 1 are already occupied (hd0 and cdrom)
stg_params += _add_param("drive_index", 'range(2,n)')
param_matrix = {}
stg_params = stg_params.split(' ')
i = 0
while i < len(stg_params) - 1:
if not stg_params[i].strip():
i += 1
continue
if stg_params[i][-1] == '\\':
stg_params[i] = '%s %s' % (stg_params[i][:-1],
stg_params.pop(i + 1))
i += 1
rerange = []
has_name = False
for i in xrange(len(stg_params)):
if not stg_params[i].strip():
continue
(cmd, parm) = stg_params[i].split(':', 1)
if cmd == "image_name":
has_name = True
if _RE_RANGE1.match(parm):
parm = _range(parm)
if parm is False:
raise error.TestError("Incorrect cfg: stg_params %s looks "
"like range(..) but doesn't contain "
"numbers." % cmd)
param_matrix[cmd] = parm
if type(parm) is str:
# When we know the stg_image_num, substitute it.
rerange.append(cmd)
continue
else:
# ',' separated list of values
parm = parm.split(',')
j = 0
while j < len(parm) - 1:
if parm[j][-1] == '\\':
parm[j] = '%s,%s' % (parm[j][:-1], parm.pop(j + 1))
j += 1
param_matrix[cmd] = parm
stg_image_num = max(stg_image_num, len(parm))
stg_image_num = int(params.get('stg_image_num', stg_image_num))
for cmd in rerange:
param_matrix[cmd] = _range(param_matrix[cmd], stg_image_num)
# param_table* are for pretty print of param_matrix
param_table = []
param_table_header = ['name']
if not has_name:
param_table_header.append('image_name')
for _ in param_matrix:
param_table_header.append(_)
stg_image_name = params.get('stg_image_name', 'images/%s')
for i in xrange(stg_image_num):
name = "stg%d" % i
params['images'] += " %s" % name
param_table.append([])
param_table[-1].append(name)
if not has_name:
params["image_name_%s" % name] = stg_image_name % name
param_table[-1].append(params.get("image_name_%s" % name))
for parm in param_matrix.iteritems():
params['%s_%s' % (parm[0], name)] = str(parm[1][i % len(parm[1])])
param_table[-1].append(params.get('%s_%s' % (parm[0], name)))
if params.get("multi_disk_params_only") == 'yes':
# Only print the test param_matrix and finish
logging.info('Newly added disks:\n%s',
utils.matrix_to_string(param_table, param_table_header))
return
# Always recreate VMs and disks
error.context("Start the guest with new disks", logging.info)
for vm_name in params.objects("vms"):
vm_params = params.object_params(vm_name)
env_process.process_images(env_process.preprocess_image, test,
vm_params)
error.context("Start the guest with those disks", logging.info)
vm = env.get_vm(params["main_vm"])
vm.create(timeout=max(10, stg_image_num), params=params)
session = vm.wait_for_login(timeout=int(params.get("login_timeout", 360)))
n_repeat = int(params.get("n_repeat", "1"))
file_system = [_.strip() for _ in params.get("file_system").split()]
cmd_timeout = float(params.get("cmd_timeout", 360))
re_str = params["re_str"]
black_list = params["black_list"].split()
os_type = params["os_type"]
stg_image_size = params.get("stg_image_size")
disk_indexs = []
have_qtree = True
out = vm.monitor.human_monitor_cmd("info qtree", debug=False)
if "unknown command" in str(out):
have_qtree = False
if (params.get("check_guest_proc_scsi") == "yes") and have_qtree:
error.context("Verifying qtree vs. test params")
err = 0
qtree = qemu_qtree.QtreeContainer()
qtree.parse_info_qtree(vm.monitor.info('qtree'))
disks = qemu_qtree.QtreeDisksContainer(qtree.get_nodes())
(tmp1, tmp2) = disks.parse_info_block(vm.monitor.info_block())
err += tmp1 + tmp2
err += disks.generate_params()
err += disks.check_disk_params(params)
(tmp1, tmp2, _, _) = disks.check_guests_proc_scsi(
session.cmd_output('cat /proc/scsi/scsi'))
err += tmp1 + tmp2
if err:
raise error.TestFail("%s errors occurred while verifying"
" qtree vs. params" % err)
if params.get('multi_disk_only_qtree') == 'yes':
return
try:
cmd = params.get("clean_cmd")
if cmd:
session.cmd_status_output(cmd)
if params.get("os_type") == "windows":
error.context("Create partition on those disks", logging.info)
# Get the disk index
_get_disk_index(session, stg_image_size, disk_indexs)
if len(disk_indexs) < stg_image_num:
err_msg = "Set disks num: %d" % stg_image_num
err_msg += ", Get disks num in guest: %d" % len(disk_indexs)
raise error.TestFail("Fail to list all the volumes, %s" % err_msg)
# Random select one file system from file_system
index = random.randint(0, (len(file_system) - 1))
fs_type = file_system[index].strip()
for i in xrange(stg_image_num):
utils_misc.format_windows_disk(session, disk_indexs[i], None,
None, fs_type)
error.context("Get disks dev filenames in guest", logging.info)
cmd = params["list_volume_command"]
s, output = session.cmd_status_output(cmd, timeout=cmd_timeout)
if s != 0:
raise error.TestFail("List volume command failed with cmd '%s'.\n"
"Output is: %s\n" % (cmd, output))
output = session.cmd_output(cmd, timeout=cmd_timeout)
disks = re.findall(re_str, output)
disks = map(string.strip, disks)
disks.sort()
logging.debug("Volume list that meet regular expressions: %s",
" ".join(disks))
images = params.get("images").split()
if len(disks) < len(images):
logging.debug("disks: %s , images: %s", len(disks), len(images))
raise error.TestFail("Fail to list all the volumes!")
if params.get("os_type") == "linux":
output = session.cmd_output("mount")
li = re.findall(r"^/dev/(%s)\d*" % re_str, output, re.M)
if li:
black_list.extend(li)
else:
black_list.extend(utils_misc.get_winutils_vol(session))
disks = set(disks)
black_list = set(black_list)
logging.info("No need to check volume '%s'", (disks & black_list))
disks = disks - black_list
except Exception:
_do_post_cmd(session)
raise
try:
for i in range(n_repeat):
logging.info("iterations: %s", (i + 1))
error.context("Format those disks in guest", logging.info)
for disk in disks:
disk = disk.strip()
error.context("Preparing disk: %s..." % disk)
# Random select one file system from file_system
index = random.randint(0, (len(file_system) - 1))
fs = file_system[index].strip()
cmd = params["format_command"] % (fs, disk)
error.context("formatting test disk")
session.cmd(cmd, timeout=cmd_timeout)
cmd = params.get("mount_command")
if cmd:
cmd = cmd % (disk, disk, disk)
session.cmd(cmd)
error.context("Cope file into / out of those disks", logging.info)
for disk in disks:
disk = disk.strip()
error.context("Performing I/O on disk: %s..." % disk)
cmd_list = params["cmd_list"].split()
for cmd_l in cmd_list:
cmd = params.get(cmd_l)
if cmd:
session.cmd(cmd % disk, timeout=cmd_timeout)
cmd = params["compare_command"]
key_word = params["check_result_key_word"]
output = session.cmd_output(cmd)
if key_word not in output:
raise error.TestFail("Files on guest os root fs and disk "
"differ")
if params.get("umount_command"):
cmd = params.get("show_mount_cmd")
output = session.cmd_output(cmd)
disks = re.findall(re_str, output)
disks.sort()
for disk in disks:
disk = disk.strip()
error.context("Unmounting disk: %s..." % disk)
cmd = params.get("umount_command") % (disk, disk)
session.cmd(cmd)
finally:
cmd = params.get("show_mount_cmd")
if cmd:
try:
output = session.cmd_output(cmd)
disks = re.findall(re_str, output)
disks.sort()
for disk in disks:
error.context("Unmounting disk: %s..." % disk)
cmd = params["umount_command"] % (disk, disk)
session.cmd(cmd)
except Exception, err:
logging.warn("Get error when cleanup, '%s'", err)
_do_post_cmd(session)
session.close()
error.context("Check image size in guest", logging.info)
block_size = get_block_size(session, block_size_cmd, block_size_pattern)
if (block_size > data_image_size or
block_size < data_image_size * (1 - accept_ratio)):
raise error.TestError("Image size from guest and image not match"
"Block size get from guest: %s \n"
"Image size get from image: %s \n"
% (block_size, data_image_size))
if params.get("guest_prepare_cmd"):
session.cmd(params.get("guest_prepare_cmd"))
if params.get("format_disk", "no") == "yes":
error.context("Format disk", logging.info)
utils_misc.format_windows_disk(session, params["disk_index"],
mountpoint=params["disk_letter"])
disk_update_cmd = params.get("disk_update_cmd")
if disk_update_cmd:
disk_update_cmd = disk_update_cmd.split("::")
disk_rescan_cmd = params.get("disk_rescan_cmd")
block_size = data_image_size
disk_change_ratio = params["disk_change_ratio"]
for index, ratio in enumerate(disk_change_ratio.strip().split()):
old_block_size = block_size
block_size = int(int(data_image_size) * float(ratio))
if block_size == old_block_size:
logging.warn("Block size is not changed in round %s."
error.context("Check image size in guest", logging.info)
block_size = get_block_size(session, block_size_cmd, block_size_pattern)
if (block_size > data_image_size
or block_size < data_image_size * (1 - accept_ratio)):
raise error.TestError("Image size from guest and image not match"
"Block size get from guest: %s \n"
"Image size get from image: %s \n" %
(block_size, data_image_size))
if params.get("guest_prepare_cmd"):
session.cmd(params.get("guest_prepare_cmd"))
if params.get("format_disk", "no") == "yes":
error.context("Format disk", logging.info)
utils_misc.format_windows_disk(session,
params["disk_index"],
mountpoint=params["disk_letter"])
disk_update_cmd = params.get("disk_update_cmd")
if disk_update_cmd:
disk_update_cmd = disk_update_cmd.split("::")
disk_rescan_cmd = params.get("disk_rescan_cmd")
block_size = data_image_size
disk_change_ratio = params["disk_change_ratio"]
for index, ratio in enumerate(disk_change_ratio.strip().split()):
old_block_size = block_size
block_size = int(int(data_image_size) * float(ratio))
if block_size == old_block_size:
def run(test, params, env):
"""
Run IOzone for windows on a windows guest:
1) Log into a guest
2) Execute the IOzone test contained in the winutils.iso
3) Get results
4) Postprocess it with the IOzone postprocessing module
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def post_result(results_path, analysisdir):
"""
Pick results from an IOzone run, generate a series graphs
:params results_path: iozone test result path
:params analysisdir: output of analysis result
"""
a = postprocess_iozone.IOzoneAnalyzer(list_files=[results_path],
output_dir=analysisdir)
a.analyze()
p = postprocess_iozone.IOzonePlotter(results_file=results_path,
output_dir=analysisdir)
p.plot_all()
def get_driver():
"""
Get driver name
"""
driver_name = params.get("driver_name", "")
drive_format = params.get("drive_format")
if not driver_name:
if "scsi" in drive_format:
driver_name = "vioscsi"
elif "virtio" in drive_format:
driver_name = "viostor"
else:
driver_name = None
return driver_name
timeout = int(params.get("login_timeout", 360))
iozone_timeout = int(params.get("iozone_timeout"))
disk_letter = params.get("disk_letter", 'C')
disk_index = params.get("disk_index", "2")
results_path = os.path.join(test.resultsdir,
'raw_output_%s' % test.iteration)
analysisdir = os.path.join(test.resultsdir, 'analysis_%s' % test.iteration)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session = vm.wait_for_login(timeout=timeout)
driver_name = get_driver()
if driver_name:
session = utils_test.qemu.windrv_check_running_verifier(session, vm,
test, driver_name,
timeout)
if params.get("format_disk", "no") == "yes":
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session, disk_index,
mountpoint=disk_letter)
cmd = params["iozone_cmd"]
iozone_cmd = utils_misc.set_winutils_letter(session, cmd)
error_context.context("Running IOzone command on guest, timeout %ss"
% iozone_timeout, logging.info)
status, results = session.cmd_status_output(cmd=iozone_cmd,
timeout=iozone_timeout)
error_context.context("Write results to %s" % results_path, logging.info)
if status != 0:
test.fail("iozone test failed: %s" % results)
with open(results_path, 'w') as file:
file.write(results)
if params.get("post_result", "no") == "yes":
error_context.context("Generate graph of test result", logging.info)
post_result(results_path, analysisdir)
def run(test, params, env):
"""
KVM block resize test:
1) Start guest with data image and check the data image size.
2) Enlarge(or Decrease) the data image and check it in guest.
:param test: QEMU test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def get_block_size(session, block_cmd, block_pattern):
"""
Get block size inside guest.
"""
output = session.cmd_output(block_cmd)
block_size = re.findall(block_pattern, output)
if block_size:
if not re.search("[a-zA-Z]", block_size[0]):
return int(block_size[0])
else:
return float(utils_misc.normalize_data_size(block_size[0],
order_magnitude="B"))
else:
raise error.TestError("Can not find the block size for the"
" deivce. The output of command"
" is: %s" % output)
def compare_block_size(session, block_cmd, block_pattern):
"""
Compare the current block size with the expected size.
"""
global current_size
current_size = get_block_size(session,
block_size_cmd, block_size_pattern)
if (current_size <= block_size and
current_size >= block_size * (1 - accept_ratio)):
logging.info("Block Resizing Finished !!! \n"
"Current size %s is same as the expected %s",
current_size, block_size)
return True
return
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
timeout = float(params.get("login_timeout", 240))
driver_name = params.get("driver_name")
if params.get("os_type") == "windows":
utils_test.qemu.setup_win_driver_verifier(driver_name, vm, timeout)
session = vm.wait_for_login(timeout=timeout)
data_image = params.get("images").split()[-1]
data_image_params = params.object_params(data_image)
data_image_size = data_image_params.get("image_size")
data_image_size = float(utils_misc.normalize_data_size(data_image_size,
order_magnitude="B"))
data_image_filename = storage.get_image_filename(data_image_params,
data_dir.get_data_dir())
data_image_dev = vm.get_block({'file': data_image_filename})
drive_path = ""
if params.get("os_type") == 'linux':
drive_id = params["blk_extra_params_%s" % data_image].split("=")[1]
drive_path = utils_misc.get_linux_drive_path(session, drive_id)
if not drive_path:
raise error.TestError("Failed to get '%s' drive path"
% data_image)
block_size_cmd = params["block_size_cmd"].format(drive_path)
block_size_pattern = params.get("block_size_pattern")
need_reboot = params.get("need_reboot", "no") == "yes"
accept_ratio = float(params.get("accept_ratio", 0))
error.context("Check image size in guest", logging.info)
block_size = get_block_size(session, block_size_cmd, block_size_pattern)
if (block_size > data_image_size or
block_size < data_image_size * (1 - accept_ratio)):
raise error.TestError("Image size from guest and image not match"
"Block size get from guest: %s \n"
"Image size get from image: %s \n"
% (block_size, data_image_size))
if params.get("guest_prepare_cmd"):
session.cmd(params.get("guest_prepare_cmd"))
if params.get("format_disk", "no") == "yes":
error.context("Format disk", logging.info)
utils_misc.format_windows_disk(session, params["disk_index"],
mountpoint=params["disk_letter"])
disk_update_cmd = params.get("disk_update_cmd")
if disk_update_cmd:
disk_update_cmd = disk_update_cmd.split("::")
disk_rescan_cmd = params.get("disk_rescan_cmd")
block_size = data_image_size
disk_change_ratio = params["disk_change_ratio"]
for index, ratio in enumerate(disk_change_ratio.strip().split()):
old_block_size = block_size
block_size = int(int(data_image_size) * float(ratio))
if block_size == old_block_size:
logging.warn("Block size is not changed in round %s."
" Just skip it" % index)
continue
if disk_update_cmd:
if "DISK_CHANGE_SIZE" in disk_update_cmd[index]:
disk_unit = params.get("disk_unit", "M")
size = abs(block_size - old_block_size)
change_size = utils_misc.normalize_data_size("%sB" % size,
disk_unit)
disk_update_cmd[index] = re.sub("DISK_CHANGE_SIZE",
change_size.split(".")[0],
disk_update_cmd[index])
# So far only virtio drivers support online auto block size change in
# linux guest. So we need manully update the the disk or even reboot
# guest to get the right block size after change it from monitor.
# We need shrink the disk in guest first, than in monitor
if block_size < old_block_size and disk_update_cmd:
error.context("Shrink disk size to %s in guest"
% block_size, logging.info)
session.cmd(disk_update_cmd[index])
error.context("Change disk size to %s in monitor"
% block_size, logging.info)
vm.monitor.block_resize(data_image_dev, block_size)
if need_reboot:
session = vm.reboot(session=session)
elif disk_rescan_cmd:
error.context("Rescan disk", logging.info)
session.cmd(disk_rescan_cmd)
# We need expand disk in monitor first than extend it in guest
if block_size > old_block_size and disk_update_cmd:
error.context("Extend disk to %s in guest"
% block_size, logging.info)
session.cmd(disk_update_cmd[index])
global current_size
current_size = 0
if not utils_misc.wait_for(lambda: compare_block_size
(session, block_size_cmd,
block_size_pattern),
20, 0, 1, "Block Resizing"):
raise error.TestFail("Block size get from guest is not"
"the same as expected \n"
"Reported: %s\n"
"Expect: %s\n" % (current_size,
block_size))
def run(test, params, env):
"""
Test hotplug of block devices.
1) Boot up guest with/without block device(s).
2) Hoplug block device and verify
3) Do read/write data on hotplug block.
4) Unplug block device and verify
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def find_image(image_name):
"""
Find the path of the iamge.
"""
image_params = params.object_params(image_name)
o = storage.get_image_filename(image_params, data_dir.get_data_dir())
return o
def find_disk(vm, cmd):
"""
Find all disks in guest.
"""
if params.get("os_type") == "linux":
pattern = params.get("get_disk_pattern", "^/dev/vd[a-z]*$")
elif params.get("os_type") == "windows":
pattern = "^\d+"
cmd = params.get("get_disk_index", "wmic diskdrive get index")
else:
test.cancel("Unsupported OS type '%s'" % params.get("os_type"))
session = vm.wait_for_login(timeout=timeout)
output = session.cmd_output_safe(cmd)
disks = re.findall(pattern, output, re.M)
session.close()
return disks
def get_new_disk(disk1, disk2):
"""
Get the different disk between disk1 and disk2.
"""
disk = list(set(disk2).difference(set(disk1)))
return disk
img_list = params.get("images").split()
img_format_type = params.get("img_format_type", "qcow2")
pci_type = params.get("pci_type", "virtio-blk-pci")
#sometimes, ppc can't get new plugged disk in 5s, so time to 10s
pause = float(params.get("virtio_block_pause", 10.0))
blk_num = int(params.get("blk_num", 1))
repeat_times = int(params.get("repeat_times", 3))
timeout = int(params.get("login_timeout", 360))
disk_op_timeout = int(params.get("disk_op_timeout", 360))
get_disk_cmd = params.get("get_disk_cmd")
context_msg = "Running sub test '%s' %s"
device_list = []
disk_index = params.objects("disk_index")
disk_letter = params.objects("disk_letter")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
for iteration in xrange(repeat_times):
error_context.context(
"Hotplug block device (iteration %d)" % iteration, logging.info)
sub_type = params.get("sub_type_before_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "before hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
for num in xrange(blk_num):
device = qdevices.QDevice(pci_type)
if params.get("need_plug") == "yes":
disks_before_plug = find_disk(vm, get_disk_cmd)
if params.get("need_controller", "no") == "yes":
controller_model = params.get("controller_model")
controller = qdevices.QDevice(controller_model)
bus_extra_param = params.get("bus_extra_params_%s" %
img_list[num + 1])
# TODO:Add iothread support for qdevice
if bus_extra_param and "iothread" in bus_extra_param:
match = re.search("iothread=(\w+)", bus_extra_param)
if match:
qdevice_params = {"iothread": match.group(1)}
controller.params.update(qdevice_params)
controller.hotplug(vm.monitor)
ver_out = controller.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % controller_model
test.fail(err)
drive = qdevices.QRHDrive("block%d" % num)
drive.set_param("file", find_image(img_list[num + 1]))
drive.set_param("format", img_format_type)
drive_id = drive.get_param("id")
drive.hotplug(vm.monitor)
device.set_param("drive", drive_id)
device.set_param("id", "block%d" % num)
blk_extra_param = params.get("blk_extra_params_%s" %
img_list[num + 1])
if blk_extra_param and "iothread" in blk_extra_param:
match = re.search("iothread=(\w+)", blk_extra_param)
if match:
device.set_param("iothread", match.group(1))
device.hotplug(vm.monitor)
ver_out = device.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % pci_type
test.fail(err)
plug_status = utils_misc.wait_for(
lambda: len(
get_new_disk(disks_before_plug,
find_disk(vm, get_disk_cmd))) != 0, pause)
if plug_status:
disks_after_plug = find_disk(vm, get_disk_cmd)
new_disks = get_new_disk(disks_before_plug,
disks_after_plug)
else:
test.fail("Can't get new disks")
else:
if params.get("drive_format") in pci_type:
get_disk_cmd += " | egrep -v '^/dev/[hsv]da[0-9]*$'"
device.set_param("id", img_list[num + 1])
new_disks = find_disk(vm, get_disk_cmd)
device_list.append(device)
if not new_disks:
test.fail("Cannot find new disk after hotplug.")
if params.get("need_plug") == "yes":
disk = new_disks[0]
else:
disk = new_disks[num]
session = vm.wait_for_login(timeout=timeout)
if params.get("os_type") == "windows":
if iteration == 0:
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session,
disk_index[num],
mountpoint=disk_letter[num])
error_context.context("Check block device after hotplug.",
logging.info)
if params.get("disk_op_cmd"):
if params.get("os_type") == "linux":
test_cmd = params.get("disk_op_cmd") % (disk, disk)
elif params.get("os_type") == "windows":
test_cmd = params.get("disk_op_cmd") % (disk_letter[num],
disk_letter[num])
test_cmd = utils_misc.set_winutils_letter(
session, test_cmd)
else:
test.cancel("Unsupported OS type '%s'" %
params.get("os_type"))
status, output = session.cmd_status_output(
test_cmd, timeout=disk_op_timeout)
if status:
test.fail("Check for block device failed "
"after hotplug, Output: %r" % output)
session.close()
sub_type = params.get("sub_type_after_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "after hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
if vm.is_dead():
return
sub_type = params.get("sub_type_before_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "before unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
for num in xrange(blk_num):
error_context.context(
"Unplug block device (iteration %d)" % iteration, logging.info)
disks_before_unplug = find_disk(vm, get_disk_cmd)
device_list[num].unplug(vm.monitor)
device_list[num].verify_unplug("", vm.monitor)
unplug_status = utils_misc.wait_for(
lambda: len(
get_new_disk(find_disk(vm, get_disk_cmd),
disks_before_unplug)) != 0, pause)
if not unplug_status:
test.fail("Failed to unplug disks")
sub_type = params.get("sub_type_after_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "after unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
def run(test, params, env):
"""
Test hotplug of block devices.
1) Boot up guest with/without block device(s).
2) Hoplug block device and verify
3) Do read/write data on hotplug block.
4) Unplug block device and verify
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def find_disk(vm, cmd):
"""
Find all disks in guest.
"""
if params.get("os_type") == "linux":
pattern = params.get("get_disk_pattern", "^/dev/vd[a-z]*$")
elif params.get("os_type") == "windows":
pattern = r"^\d+"
cmd = params.get("get_disk_index", "wmic diskdrive get index")
else:
test.cancel("Unsupported OS type '%s'" % params.get("os_type"))
session = vm.wait_for_login(timeout=timeout)
output = session.cmd_output_safe(cmd)
disks = re.findall(pattern, output, re.M)
session.close()
return disks
def get_new_disk(disk1, disk2):
"""
Get the different disk between disk1 and disk2.
"""
disk = list(set(disk2).difference(set(disk1)))
return disk
def run_sub_test(params, plug_tag):
"""
Run subtest before/after hotplug/unplug device.
:param plug_tag: identify when to run subtest,
ex, before_hotplug.
:return: whether vm was successfully shut-down
if needed
"""
sub_type = params.get("sub_type_%s" % plug_tag)
if sub_type:
error_context.context(context_msg % (sub_type, plug_tag),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
if sub_type == "shutdown" and vm.is_dead():
return True
return None
img_list = params.get("images").split()
#sometimes, ppc can't get new plugged disk in 5s, so time to 10s
pause = float(params.get("virtio_block_pause", 10.0))
blk_num = int(params.get("blk_num", 1))
repeat_times = int(params.get("repeat_times", 3))
timeout = int(params.get("login_timeout", 360))
disk_op_timeout = int(params.get("disk_op_timeout", 360))
get_disk_cmd = params.get("get_disk_cmd")
context_msg = "Running sub test '%s' %s"
disk_index = params.objects("disk_index")
disk_letter = params.objects("disk_letter")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
for iteration in range(repeat_times):
device_list = []
error_context.context("Hotplug block device (iteration %d)" % iteration,
logging.info)
plug_tag = "before_plug"
run_sub_test(params, plug_tag)
for num in range(blk_num):
image_name = img_list[num + 1]
image_params = params.object_params(image_name)
if params.get("need_plug") == "yes":
disks_before_plug = find_disk(vm, get_disk_cmd)
devs = vm.devices.images_define_by_params(image_name,
image_params, 'disk')
for dev in devs:
ret = vm.devices.simple_hotplug(dev, vm.monitor)
if ret[1] is False:
test.fail("Failed to hotplug device '%s'."
"Output:\n%s" % (dev, ret[0]))
plug_disks = utils_misc.wait_for(lambda: get_new_disk(disks_before_plug,
find_disk(vm, get_disk_cmd)), pause)
if not plug_disks:
test.fail("Failed to hotplug device to guest")
disk = plug_disks[0]
session = vm.wait_for_login(timeout=timeout)
if params.get("os_type") == "windows":
if iteration == 0:
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session, disk_index[num],
mountpoint=disk_letter[num])
error_context.context("Check block device after hotplug.",
logging.info)
if params.get("disk_op_cmd"):
if params.get("os_type") == "linux":
test_cmd = params.get("disk_op_cmd") % (disk, disk)
elif params.get("os_type") == "windows":
test_cmd = params.get("disk_op_cmd") % (disk_letter[num],
disk_letter[num])
test_cmd = utils_misc.set_winutils_letter(session, test_cmd)
else:
test.cancel("Unsupported OS type '%s'" % params.get("os_type"))
status, output = session.cmd_status_output(test_cmd,
timeout=disk_op_timeout)
if status:
test.fail("Check for block device failed."
"Output: %s" % output)
session.close()
devs = [dev for dev in devs if not isinstance(dev, qdevices.QDrive)]
device_list.extend(devs)
else:
for device in vm.devices:
if device.get_param("id") == img_list[num + 1]:
device_list.append(device)
plug_tag = "after_plug"
vm_switched_off = run_sub_test(params, plug_tag)
if vm_switched_off:
return
plug_tag = "before_unplug"
run_sub_test(params, plug_tag)
error_context.context("Unplug block device (iteration %d)" % iteration,
logging.info)
disks_before_unplug = find_disk(vm, get_disk_cmd)
for device in reversed(device_list):
ret = vm.devices.simple_unplug(device, vm.monitor)
if ret[1] is False:
test.fail("Failed to unplug device '%s'."
"Output:\n%s" % (device, ret[0]))
unplug_disks = utils_misc.wait_for(lambda: get_new_disk(find_disk(vm, get_disk_cmd),
disks_before_unplug), pause)
if len(unplug_disks) != blk_num:
test.fail("Failed to unplug devices from guest, need to unplug: %d,"
"actual unplug: %d" % (blk_num, len(unplug_disks)))
plug_tag = "after_unplug"
run_sub_test(params, plug_tag)
def run(test, params, env):
"""
Test hotplug of block devices.
1) Boot up guest with/without block device(s).
2) Hoplug block device and verify
3) Do read/write data on hotplug block.
4) Unplug block device and verify
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def find_disk(vm, cmd):
"""
Find all disks in guest.
"""
if params.get("os_type") == "linux":
pattern = params.get("get_disk_pattern", "^/dev/vd[a-z]*$")
elif params.get("os_type") == "windows":
pattern = r"^\d+"
cmd = params.get("get_disk_index", "wmic diskdrive get index")
else:
test.cancel("Unsupported OS type '%s'" % params.get("os_type"))
session = vm.wait_for_login(timeout=timeout)
output = session.cmd_output_safe(cmd)
disks = re.findall(pattern, output, re.M)
session.close()
return disks
def get_new_disk(disk1, disk2):
"""
Get the different disk between disk1 and disk2.
"""
disk = list(set(disk2).difference(set(disk1)))
return disk
def run_sub_test(params, plug_tag):
"""
Run subtest before/after hotplug/unplug device.
:param plug_tag: identify when to run subtest,
ex, before_hotplug.
:return: whether vm was successfully shut-down
if needed
"""
sub_type = params.get("sub_type_%s" % plug_tag)
if sub_type:
error_context.context(context_msg % (sub_type, plug_tag),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
if sub_type == "shutdown" and vm.is_dead():
return True
return None
img_list = params.get("images").split()
#sometimes, ppc can't get new plugged disk in 5s, so time to 10s
pause = float(params.get("virtio_block_pause", 10.0))
blk_num = int(params.get("blk_num", 1))
repeat_times = int(params.get("repeat_times", 3))
timeout = int(params.get("login_timeout", 360))
disk_op_timeout = int(params.get("disk_op_timeout", 360))
get_disk_cmd = params.get("get_disk_cmd")
context_msg = "Running sub test '%s' %s"
disk_index = params.objects("disk_index")
disk_letter = params.objects("disk_letter")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
for iteration in range(repeat_times):
device_list = []
error_context.context(
"Hotplug block device (iteration %d)" % iteration, logging.info)
plug_tag = "before_plug"
run_sub_test(params, plug_tag)
for num in range(blk_num):
image_name = img_list[num + 1]
image_params = params.object_params(image_name)
if params.get("need_plug") == "yes":
disks_before_plug = find_disk(vm, get_disk_cmd)
devs = vm.devices.images_define_by_params(
image_name, image_params, 'disk')
for dev in devs:
ret = vm.devices.simple_hotplug(dev, vm.monitor)
if ret[1] is False:
test.fail("Failed to hotplug device '%s'."
"Output:\n%s" % (dev, ret[0]))
plug_disks = utils_misc.wait_for(
lambda: get_new_disk(disks_before_plug,
find_disk(vm, get_disk_cmd)), pause)
if not plug_disks:
test.fail("Failed to hotplug device to guest")
disk = plug_disks[0]
session = vm.wait_for_login(timeout=timeout)
if params.get("os_type") == "windows":
if iteration == 0:
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(
session,
disk_index[num],
mountpoint=disk_letter[num])
error_context.context("Check block device after hotplug.",
logging.info)
if params.get("disk_op_cmd"):
if params.get("os_type") == "linux":
test_cmd = params.get("disk_op_cmd") % (disk, disk)
elif params.get("os_type") == "windows":
test_cmd = params.get("disk_op_cmd") % (
disk_letter[num], disk_letter[num])
test_cmd = utils_misc.set_winutils_letter(
session, test_cmd)
else:
test.cancel("Unsupported OS type '%s'" %
params.get("os_type"))
status, output = session.cmd_status_output(
test_cmd, timeout=disk_op_timeout)
if status:
test.fail("Check for block device failed."
"Output: %s" % output)
devs = [
dev for dev in devs
if not isinstance(dev, qdevices.QDrive)
]
device_list.extend(devs)
else:
for device in vm.devices:
if device.get_param("id") == img_list[num + 1]:
device_list.append(device)
plug_tag = "after_plug"
vm_switched_off = run_sub_test(params, plug_tag)
if vm_switched_off:
return
plug_tag = "before_unplug"
run_sub_test(params, plug_tag)
error_context.context("Unplug block device (iteration %d)" % iteration,
logging.info)
disks_before_unplug = find_disk(vm, get_disk_cmd)
for device in reversed(device_list):
ret = vm.devices.simple_unplug(device, vm.monitor)
if ret[1] is False:
test.fail("Failed to unplug device '%s'."
"Ouptut:\n%s" % (dev, ret[0]))
unplug_disks = utils_misc.wait_for(
lambda: get_new_disk(find_disk(vm, get_disk_cmd),
disks_before_unplug), pause)
if len(unplug_disks) != blk_num:
test.fail(
"Failed to unplug devices from guest, need to unplug: %d,"
"actual unplug: %d" % (blk_num, len(unplug_disks)))
plug_tag = "after_unplug"
run_sub_test(params, plug_tag)
def run(test, params, env):
"""
Test hotplug of block devices.
1) Boot up guest with/without block device(s).
2) Hoplug block device and verify
3) Do read/write data on hotplug block.
4) Unplug block device and verify
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def find_image(image_name):
"""
Find the path of the iamge.
"""
image_params = params.object_params(image_name)
o = storage.get_image_filename(image_params, data_dir.get_data_dir())
return o
def find_disk(vm, cmd):
"""
Find all disks in guest.
"""
if params.get("os_type") == "linux":
pattern = params.get("get_disk_pattern", "^/dev/vd[a-z]*$")
elif params.get("os_type") == "windows":
pattern = "^\d+"
cmd = params.get("get_disk_index", "wmic diskdrive get index")
else:
test.cancel("Unsupported OS type '%s'" % params.get("os_type"))
session = vm.wait_for_login(timeout=timeout)
output = session.cmd_output_safe(cmd)
disks = re.findall(pattern, output, re.M)
session.close()
return disks
def get_new_disk(disk1, disk2):
"""
Get the different disk between disk1 and disk2.
"""
disk = list(set(disk2).difference(set(disk1)))
return disk
img_list = params.get("images").split()
img_format_type = params.get("img_format_type", "qcow2")
pci_type = params.get("pci_type", "virtio-blk-pci")
#sometimes, ppc can't get new plugged disk in 5s, so time to 10s
pause = float(params.get("virtio_block_pause", 10.0))
blk_num = int(params.get("blk_num", 1))
repeat_times = int(params.get("repeat_times", 3))
timeout = int(params.get("login_timeout", 360))
disk_op_timeout = int(params.get("disk_op_timeout", 360))
get_disk_cmd = params.get("get_disk_cmd")
context_msg = "Running sub test '%s' %s"
device_list = []
disk_index = params.objects("disk_index")
disk_letter = params.objects("disk_letter")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
for iteration in xrange(repeat_times):
error_context.context("Hotplug block device (iteration %d)" % iteration,
logging.info)
sub_type = params.get("sub_type_before_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "before hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
for num in xrange(blk_num):
device = qdevices.QDevice(pci_type)
if params.get("need_plug") == "yes":
disks_before_plug = find_disk(vm, get_disk_cmd)
if params.get("need_controller", "no") == "yes":
controller_model = params.get("controller_model")
controller = qdevices.QDevice(controller_model)
bus_extra_param = params.get("bus_extra_params_%s" % img_list[num + 1])
# TODO:Add iothread support for qdevice
if bus_extra_param and "iothread" in bus_extra_param:
match = re.search("iothread=(\w+)", bus_extra_param)
if match:
qdevice_params = {"iothread": match.group(1)}
controller.params.update(qdevice_params)
controller.hotplug(vm.monitor)
ver_out = controller.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % controller_model
test.fail(err)
drive = qdevices.QRHDrive("block%d" % num)
drive.set_param("file", find_image(img_list[num + 1]))
drive.set_param("format", img_format_type)
drive_id = drive.get_param("id")
drive.hotplug(vm.monitor)
device.set_param("drive", drive_id)
device.set_param("id", "block%d" % num)
blk_extra_param = params.get("blk_extra_params_%s" % img_list[num + 1])
if blk_extra_param and "iothread" in blk_extra_param:
match = re.search("iothread=(\w+)", blk_extra_param)
if match:
device.set_param("iothread", match.group(1))
device.hotplug(vm.monitor)
ver_out = device.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % pci_type
test.fail(err)
plug_status = utils_misc.wait_for(lambda: len(get_new_disk(disks_before_plug,
find_disk(vm, get_disk_cmd))) != 0, pause)
if plug_status:
disks_after_plug = find_disk(vm, get_disk_cmd)
new_disks = get_new_disk(disks_before_plug, disks_after_plug)
else:
test.fail("Can't get new disks")
else:
if params.get("drive_format") in pci_type:
get_disk_cmd += " | egrep -v '^/dev/[hsv]da[0-9]*$'"
device.set_param("id", img_list[num + 1])
new_disks = find_disk(vm, get_disk_cmd)
device_list.append(device)
if not new_disks:
test.fail("Cannot find new disk after hotplug.")
if params.get("need_plug") == "yes":
disk = new_disks[0]
else:
disk = new_disks[num]
session = vm.wait_for_login(timeout=timeout)
if params.get("os_type") == "windows":
if iteration == 0:
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session, disk_index[num],
mountpoint=disk_letter[num])
error_context.context("Check block device after hotplug.",
logging.info)
if params.get("disk_op_cmd"):
if params.get("os_type") == "linux":
test_cmd = params.get("disk_op_cmd") % (disk, disk)
elif params.get("os_type") == "windows":
test_cmd = params.get("disk_op_cmd") % (disk_letter[num],
disk_letter[num])
test_cmd = utils_misc.set_winutils_letter(session, test_cmd)
else:
test.cancel("Unsupported OS type '%s'" % params.get("os_type"))
status, output = session.cmd_status_output(test_cmd,
timeout=disk_op_timeout)
if status:
test.fail("Check for block device failed "
"after hotplug, Output: %r" % output)
session.close()
sub_type = params.get("sub_type_after_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "after hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
if vm.is_dead():
return
sub_type = params.get("sub_type_before_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "before unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
for num in xrange(blk_num):
error_context.context("Unplug block device (iteration %d)" % iteration,
logging.info)
disks_before_unplug = find_disk(vm, get_disk_cmd)
device_list[num].unplug(vm.monitor)
device_list[num].verify_unplug("", vm.monitor)
unplug_status = utils_misc.wait_for(lambda: len(get_new_disk(find_disk(vm, get_disk_cmd),
disks_before_unplug)) != 0, pause)
if not unplug_status:
test.fail("Failed to unplug disks")
sub_type = params.get("sub_type_after_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "after unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
def run(test, params, env):
"""
Run IOzone for windows on a windows guest:
1) Log into a guest
2) Execute the IOzone test contained in the winutils.iso
3) Get results
4) Postprocess it with the IOzone postprocessing module
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
def post_result(results_path, analysisdir):
"""
Pick results from an IOzone run, generate a series graphs
:params results_path: iozone test result path
:params analysisdir: output of analysis result
"""
a = postprocess_iozone.IOzoneAnalyzer(list_files=[results_path],
output_dir=analysisdir)
a.analyze()
p = postprocess_iozone.IOzonePlotter(results_file=results_path,
output_dir=analysisdir)
p.plot_all()
def get_driver():
"""
Get driver name
"""
driver_name = params.get("driver_name", "")
drive_format = params.get("drive_format")
if not driver_name:
if "scsi" in drive_format:
driver_name = "vioscsi"
elif "virtio" in drive_format:
driver_name = "viostor"
else:
driver_name = None
return driver_name
timeout = int(params.get("login_timeout", 360))
iozone_timeout = int(params.get("iozone_timeout"))
disk_letter = params["disk_letter"]
disk_index = params.get("disk_index", "2")
results_path = os.path.join(test.resultsdir,
'raw_output_%s' % test.iteration)
analysisdir = os.path.join(test.resultsdir, 'analysis_%s' % test.iteration)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
driver_name = get_driver()
if driver_name:
utils_test.qemu.setup_win_driver_verifier(driver_name, vm, timeout)
session = vm.wait_for_login(timeout=timeout)
if params.get("format_disk", "no") == "yes":
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session,
disk_index,
mountpoint=disk_letter)
winutils = utils_misc.get_winutils_vol(session)
cmd = params["iozone_cmd"]
iozone_cmd = re.sub("WIN_UTILS", winutils, cmd)
error_context.context(
"Running IOzone command on guest, timeout %ss" % iozone_timeout,
logging.info)
status, results = session.cmd_status_output(cmd=iozone_cmd,
timeout=iozone_timeout)
error_context.context("Write results to %s" % results_path, logging.info)
if status != 0:
raise exceptions.TestFail("iozone test failed: %s" % results)
utils.open_write_close(results_path, results)
if params.get("post_result", "no") == "yes":
error_context.context("Generate graph of test result", logging.info)
post_result(results_path, analysisdir)
def run(test, params, env):
"""
Test hotplug of block devices.
1) Boot up guest with/without block device(s).
2) Hoplug block device and verify
3) Do read/write data on hotplug block.
4) Unplug block device and verify
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def find_image(image_name):
"""
Find the path of the iamge.
"""
image_params = params.object_params(image_name)
o = storage.get_image_filename(image_params, data_dir.get_data_dir())
return o
def find_disk(vm, cmd):
"""
Find all disks in guest.
"""
if params.get("os_type") == "linux":
pattern = params.get("get_disk_pattern", "^/dev/vd[a-z]*$")
elif params.get("os_type") == "windows":
pattern = r"^\d+"
cmd = params.get("get_disk_index", "wmic diskdrive get index")
else:
test.cancel("Unsupported OS type '%s'" % params.get("os_type"))
session = vm.wait_for_login(timeout=timeout)
output = session.cmd_output_safe(cmd)
disks = re.findall(pattern, output, re.M)
session.close()
return disks
def get_new_disk(disk1, disk2):
"""
Get the different disk between disk1 and disk2.
"""
disk = list(set(disk2).difference(set(disk1)))
return disk
def unplug_device(vm, get_disk_cmd, device):
"""
Unplug device
"""
disks_before_unplug = find_disk(vm, get_disk_cmd)
device.unplug(vm.monitor)
device.verify_unplug("", vm.monitor)
unplug_status = utils_misc.wait_for(
lambda: len(
get_new_disk(find_disk(vm, get_disk_cmd), disks_before_unplug))
!= 0, pause)
return unplug_status
img_list = params.get("images").split()
img_format_type = params.get("img_format_type", "qcow2")
pci_type = params.get("pci_type", "virtio-blk-pci")
#sometimes, ppc can't get new plugged disk in 5s, so time to 10s
pause = float(params.get("virtio_block_pause", 10.0))
blk_num = int(params.get("blk_num", 1))
repeat_times = int(params.get("repeat_times", 3))
timeout = int(params.get("login_timeout", 360))
disk_op_timeout = int(params.get("disk_op_timeout", 360))
get_disk_cmd = params.get("get_disk_cmd")
context_msg = "Running sub test '%s' %s"
disk_index = params.objects("disk_index")
disk_letter = params.objects("disk_letter")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
for iteration in range(repeat_times):
device_list = []
controller_list = []
controller_device_dict = {}
error_context.context(
"Hotplug block device (iteration %d)" % iteration, logging.info)
sub_type = params.get("sub_type_before_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "before hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
for num in range(blk_num):
device = qdevices.QDevice(pci_type)
if params.get("need_plug") == "yes":
disks_before_plug = find_disk(vm, get_disk_cmd)
if params.get("need_controller", "no") == "yes":
controller_model = params.get("controller_model")
controller = qdevices.QDevice(
controller_model,
params={"id": "hotadded_scsi%s" % num})
bus_extra_param = params.get("bus_extra_params_%s" %
img_list[num + 1])
if bus_extra_param:
for item in bus_extra_param.split():
key, value = item.split("=", 1)
qdevice_params = {key: value}
controller.params.update(qdevice_params)
controller.hotplug(vm.monitor)
ver_out = controller.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % controller_model
test.fail(err)
else:
controller_list.append(controller)
drive = qdevices.QRHDrive("block%d" % num)
drive.set_param("file", find_image(img_list[num + 1]))
drive.set_param("format", img_format_type)
drive_id = drive.get_param("id")
drive.hotplug(vm.monitor)
device.set_param("drive", drive_id)
device.set_param("id", "block%d" % num)
if params.get("need_controller", "no") == "yes" and bool(
random.randrange(2)):
device.set_param("bus", controller.get_param("id") + '.0')
blk_extra_param = params.get("blk_extra_params_%s" %
img_list[num + 1])
if blk_extra_param:
for item in blk_extra_param.split():
key, value = item.split("=", 1)
device.set_param(key, value)
device.hotplug(vm.monitor)
ver_out = device.verify_hotplug("", vm.monitor)
if not ver_out:
err = "%s is not in qtree after hotplug" % pci_type
test.fail(err)
plug_status = utils_misc.wait_for(
lambda: len(
get_new_disk(disks_before_plug,
find_disk(vm, get_disk_cmd))) != 0, pause)
if plug_status:
disks_after_plug = find_disk(vm, get_disk_cmd)
new_disks = get_new_disk(disks_before_plug,
disks_after_plug)
else:
test.fail("Can't get new disks")
if params.get("need_controller", "no") == "yes":
info_qtree = vm.monitor.info('qtree', False)
qtree = qemu_qtree.QtreeContainer()
qtree.parse_info_qtree(info_qtree)
for node in qtree.get_nodes():
if node.qtree.get("id") == device.get_param("id"):
try:
controller_id = node.parent.qtree.get(
"id").split(".")[0]
except AttributeError:
test.fail("can't get parent of:\n%s" % node)
controller_device_dict.setdefault(
controller_id, []).append(device)
break
else:
test.fail("Can't find device '%s' in qtree" %
device.get_param("id"))
else:
if params.get("drive_format") in pci_type:
get_disk_cmd += " | egrep -v '^/dev/[hsv]da[0-9]*$'"
device.set_param("id", img_list[num + 1])
new_disks = find_disk(vm, get_disk_cmd)
device_list.append(device)
if not new_disks:
test.fail("Cannot find new disk after hotplug.")
if params.get("need_plug") == "yes":
disk = new_disks[0]
else:
disk = new_disks[num]
session = vm.wait_for_login(timeout=timeout)
if params.get("os_type") == "windows":
if iteration == 0:
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session,
disk_index[num],
mountpoint=disk_letter[num])
error_context.context("Check block device after hotplug.",
logging.info)
if params.get("disk_op_cmd"):
if params.get("os_type") == "linux":
test_cmd = params.get("disk_op_cmd") % (disk, disk)
elif params.get("os_type") == "windows":
test_cmd = params.get("disk_op_cmd") % (disk_letter[num],
disk_letter[num])
test_cmd = utils_misc.set_winutils_letter(
session, test_cmd)
else:
test.cancel("Unsupported OS type '%s'" %
params.get("os_type"))
status, output = session.cmd_status_output(
test_cmd, timeout=disk_op_timeout)
if status:
test.fail("Check for block device failed "
"after hotplug, Output: %r" % output)
session.close()
sub_type = params.get("sub_type_after_plug")
if sub_type:
error_context.context(context_msg % (sub_type, "after hotplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
if sub_type == "shutdown" and vm.is_dead():
return
sub_type = params.get("sub_type_before_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "before unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
error_context.context("Unplug block device (iteration %d)" % iteration,
logging.info)
for controller in controller_list:
controller_id = controller.get_param("id")
for device in controller_device_dict.get(controller_id, []):
unplug_status = unplug_device(vm, get_disk_cmd, device)
if not unplug_status:
test.fail("Failed to unplug disks '%s'" %
device.get_param("id"))
device_list.remove(device)
controller.unplug(vm.monitor)
for device in device_list:
unplug_status = unplug_device(vm, get_disk_cmd, device)
if not unplug_status:
test.fail("Failed to unplug disks '%s'" %
device.get_param("id"))
sub_type = params.get("sub_type_after_unplug")
if sub_type:
error_context.context(context_msg % (sub_type, "after unplug"),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
def run(test, params, env):
"""
Test hotplug of block devices.
1) Boot up guest with/without block device(s).
2) Hoplug block device and verify
3) Do read/write data on hotplug block.
4) Unplug block device and verify
:param test: QEMU test object.
:param params: Dictionary with the test parameters.
:param env: Dictionary with test environment.
"""
def find_disk(vm, cmd):
"""
Find all disks in guest.
"""
if params.get("os_type") == "linux":
pattern = params.get("get_disk_pattern", "^/dev/vd[a-z]*$")
elif params.get("os_type") == "windows":
pattern = r"^\d+"
cmd = params.get("get_disk_index", "wmic diskdrive get index")
else:
test.cancel("Unsupported OS type '%s'" % params.get("os_type"))
session = vm.wait_for_login(timeout=timeout)
output = session.cmd_output_safe(cmd)
disks = re.findall(pattern, output, re.M)
session.close()
return disks
def get_new_disk(disk1, disk2):
"""
Get the different disk between disk1 and disk2.
"""
disk = list(set(disk2).difference(set(disk1)))
return disk
def run_sub_test(params, plug_tag):
"""
Run subtest before/after hotplug/unplug device.
:param plug_tag: identify when to run subtest,
ex, before_hotplug.
:return: whether vm was successfully shut-down
if needed
"""
sub_type = params.get("sub_type_%s" % plug_tag)
if sub_type:
error_context.context(context_msg % (sub_type, plug_tag),
logging.info)
utils_test.run_virt_sub_test(test, params, env, sub_type)
if sub_type == "shutdown" and vm.is_dead():
return True
return None
def get_disk_size(did):
"""
Get the disk size from guest.
:param did: the disk of id, e.g. sdb,sda for linux, 1, 2 for windows
:return: the disk size
"""
if params['os_type'] == 'linux':
size = utils_disk.get_linux_disks(session)[did][1].strip()
else:
script = '{}_{}'.format("disk",
utils_misc.generate_random_string(6))
cmd = "echo %s > {0} && diskpart /s {0} && del /f {0}".format(
script)
p = r'Disk\s+%s\s+[A-Z]+\s+\d+\s+[A-Z]+\s+(?P<free>\d+\s+[A-Z]+)'
disk_info = session.cmd(cmd % 'list disk')
size = re.search(p % did, disk_info,
re.I | re.M).groupdict()['free'].strip()
logging.info('The size of disk[%s] is %s' % (did, size))
return size
def check_disk_size(did, excepted_size):
"""
Checkt whether the disk size is equal to excepted size.
:param did: the disk of id, e.g. sdb,sda for linux, 1, 2 for windows
:param excepted_size: the excepted size
"""
error_context.context(
'Check whether the size of the disk[%s] hot plugged is equal to '
'excepted size(%s).' % (did, excepted_size), logging.info)
value, unit = re.search(r"(\d+\.?\d*)\s*(\w?)", excepted_size).groups()
if utils_numeric.normalize_data_size(get_disk_size(did),
unit) != value:
test.fail('The size of [%s] is not equal to excepted size(%s).' %
(did, excepted_size))
img_list = params.get("images").split()
#sometimes, ppc can't get new plugged disk in 5s, so time to 10s
pause = float(params.get("virtio_block_pause", 10.0))
blk_num = int(params.get("blk_num", 1))
repeat_times = int(params.get("repeat_times", 3))
timeout = int(params.get("login_timeout", 360))
disk_op_timeout = int(params.get("disk_op_timeout", 360))
get_disk_cmd = params.get("get_disk_cmd")
context_msg = "Running sub test '%s' %s"
disk_index = params.objects("disk_index")
disk_letter = params.objects("disk_letter")
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
for iteration in range(repeat_times):
device_list = []
error_context.context(
"Hotplug block device (iteration %d)" % iteration, logging.info)
plug_tag = "before_plug"
run_sub_test(params, plug_tag)
for num in range(blk_num):
image_name = img_list[num + 1]
image_params = params.object_params(image_name)
if params.get("need_plug") == "yes":
disks_before_plug = find_disk(vm, get_disk_cmd)
devs = vm.devices.images_define_by_params(
image_name, image_params, 'disk')
for dev in devs:
ret = vm.devices.simple_hotplug(dev, vm.monitor)
if ret[1] is False:
test.fail("Failed to hotplug device '%s'."
"Output:\n%s" % (dev, ret[0]))
plug_disks = utils_misc.wait_for(
lambda: get_new_disk(disks_before_plug,
find_disk(vm, get_disk_cmd)), pause)
if not plug_disks:
test.fail("Failed to hotplug device to guest")
disk = plug_disks[0]
session = vm.wait_for_login(timeout=timeout)
if params.get('check_disk_size', 'no') == 'yes':
did = disk_index[num] if params[
'os_type'] == 'windows' else disk[5:]
check_disk_size(did, image_params['image_size'])
if params.get("os_type") == "windows":
if iteration == 0:
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(
session,
disk_index[num],
mountpoint=disk_letter[num])
error_context.context("Check block device after hotplug.",
logging.info)
if params.get("disk_op_cmd"):
if params.get("os_type") == "linux":
test_cmd = params.get("disk_op_cmd") % (disk, disk)
elif params.get("os_type") == "windows":
test_cmd = params.get("disk_op_cmd") % (
disk_letter[num], disk_letter[num])
test_cmd = utils_misc.set_winutils_letter(
session, test_cmd)
else:
test.cancel("Unsupported OS type '%s'" %
params.get("os_type"))
status, output = session.cmd_status_output(
test_cmd, timeout=disk_op_timeout)
if status:
test.fail("Check for block device failed."
"Output: %s" % output)
session.close()
dtype = qdevices.QBlockdevNode if vm.check_capability(
Flags.BLOCKDEV) else qdevices.QDrive
devs = [dev for dev in devs if not isinstance(dev, dtype)]
device_list.extend(devs)
else:
for device in vm.devices:
if device.get_param("id") == img_list[num + 1]:
device_list.append(device)
plug_tag = "after_plug"
vm_switched_off = run_sub_test(params, plug_tag)
if vm_switched_off:
return
plug_tag = "before_unplug"
run_sub_test(params, plug_tag)
error_context.context("Unplug block device (iteration %d)" % iteration,
logging.info)
disks_before_unplug = find_disk(vm, get_disk_cmd)
for device in reversed(device_list):
ret = vm.devices.simple_unplug(device, vm.monitor)
if ret[1] is False:
test.fail("Failed to unplug device '%s'."
"Output:\n%s" % (device, ret[0]))
unplug_disks = utils_misc.wait_for(
lambda: get_new_disk(find_disk(vm, get_disk_cmd),
disks_before_unplug), pause)
if len(unplug_disks) != blk_num:
test.fail(
"Failed to unplug devices from guest, need to unplug: %d,"
"actual unplug: %d" % (blk_num, len(unplug_disks)))
plug_tag = "after_unplug"
run_sub_test(params, plug_tag)
def run(test, params, env):
"""
KVM guest stop test:
1) Log into a guest
2) Check is fio.msi installed, install it if not installed.
3) Start fio test on both sys and data disk in guest
4) Get the result
:param test: kvm test object
:param params: Dictionary with the test parameters
:param env: Dictionary with test environment.
"""
install_path = params["install_path"].rstrip("\\")
fio_log_file = params.objects("fio_log_file")
fio_file_name = params.objects("fio_file_name")
fio_cmd_sys = params.get("fio_cmd") % (fio_file_name[0], "sys", fio_log_file[0])
fio_cmd_data = params.get("fio_cmd") % (fio_file_name[1], "data", fio_log_file[1])
timeout = float(params.get("login_timeout", 360))
cmd_timeout = int(params.get("cmd_timeout", "360"))
check_installed_cmd = 'dir "%s"|findstr /I fio' % install_path
check_installed_cmd = params.get("check_installed_cmd",
check_installed_cmd)
vm = env.get_vm(params["main_vm"])
vm.verify_alive()
session_sys = vm.wait_for_login(timeout=timeout)
session_data = vm.wait_for_login(timeout=timeout)
error_context.context("Format disk", logging.info)
utils_misc.format_windows_disk(session_sys, params["disk_index"],
mountpoint=params["disk_letter"])
try:
installed = session_sys.cmd_status(check_installed_cmd) == 0
if not installed:
dst = r"%s:\\" % utils_misc.get_winutils_vol(session_sys)
error_context.context("Install fio in guest", logging.info)
install_cmd = params["install_cmd"]
install_cmd = re.sub(r"DRIVE:\\+", dst, install_cmd)
session_sys.cmd(install_cmd, timeout=180)
time.sleep(30)
config_cmd = params.get("config_cmd")
if config_cmd:
session_sys.cmd(config_cmd)
error_context.context("Start fio in guest.", logging.info)
# FIXME:Here use the timeout=(cmd_timeout*2)
# Will determine a better specific calculation later
fio_thread_data = utils_misc.InterruptedThread(session_data.cmd_status_output,
(fio_cmd_data, (cmd_timeout*2)))
fio_thread_data.start()
status_sys, output_sys = session_sys.cmd_status_output(fio_cmd_sys,
timeout=(cmd_timeout*2))
status_data, output_data = fio_thread_data.join()
if status_sys or status_data:
test.error("Failed to run fio, output: %s\n%s" % (output_sys, output_data))
finally:
error_context.context("Copy fio log from guest to host.", logging.info)
try:
vm.copy_files_from(fio_log_file[0], test.resultsdir)
vm.copy_files_from(fio_log_file[1], test.resultsdir)
except Exception, err:
logging.warn("Log file copy failed: %s" % err)
session_data.close()
if session_sys:
session_sys.close()
