diff --git a/qemu/tests/cfg/virtio_fs_localfs_migration.cfg b/qemu/tests/cfg/virtio_fs_localfs_migration.cfg new file mode 100644 index 0000000000..a79a48e24a --- /dev/null +++ b/qemu/tests/cfg/virtio_fs_localfs_migration.cfg @@ -0,0 +1,122 @@ +- virtio_fs_localfs_migration: + no RHEL.6 RHEL.7 RHEL.8.0 RHEL.8.1 + no Win2008 Win7 + + type = virtio_fs_localfs_migration + virt_test_type = qemu + required_qemu = [9.0.0,) + kill_vm = yes + start_vm = yes + + filesystems = fs + filesystems_migration = targetfs + fs_driver = virtio-fs + fs_source_type = mount + fs_source_dir_fs = /var/tmp/virtio_fs_source/ + fs_source_dir_targetfs = /var/tmp/virtio_fs_target/ + fs_target = myfs + fs_dest = /mnt/${fs_target} + force_create_fs_source = no + remove_fs_source = no + fs_driver_props = {"queue-size": 1024} + fs_binary_extra_options = '' + driver_name = viofs + + test_file = 'test_file' + test_data = 'hello_virtiofs' + pre_command = "mkdir -p ${fs_source_dir_fs} ${fs_source_dir_targetfs}" + pre_command += " && echo -e ${test_data} > ${fs_source_dir_fs}/${test_file}" + pre_command += " && echo -e ${test_data} > ${fs_source_dir_targetfs}/${test_file}" + post_command = "rm -rf ${fs_source_dir_fs} ${fs_source_dir_targetfs}" + read_file_cmd = "cat %s/${test_file}" + + share_mem = yes + vm_mem_share = yes + vm_mem_backend = memory-backend-memfd + Win10.i386: + mem = 4096 + !s390, s390x: + mem_devs = mem1 + backend_mem_mem1 = memory-backend-memfd + size_mem1 = ${mem}M + use_mem_mem1 = no + guest_numa_nodes = shm0 + numa_memdev_shm0 = mem-mem1 + numa_nodeid_shm0 = 0 + Windows: + # install winfsp tool + i386, i686: + install_winfsp_path = 'C:\Program Files' + devcon_dirname = 'x86' + x86_64: + install_winfsp_path = 'C:\Program Files (x86)' + devcon_dirname = 'amd64' + install_winfsp_cmd = 'msiexec /i WIN_UTILS:\winfsp.msi /qn' + check_installed_cmd = 'dir "%s" |findstr /I winfsp' + viofs_log_file = C:\viofs_log.txt + viofs_svc_name = VirtioFsSvc + viofs_exe_path = C:\virtiofs.exe + viofs_exe_copy_cmd = xcopy %s C:\ /Y + viofs_sc_create_cmd = 'sc create ${viofs_svc_name} binpath=${viofs_exe_path} start=auto' + viofs_sc_create_cmd += ' depend="WinFsp.Launcher/VirtioFsDrv" DisplayName="Virtio FS Service"' + viofs_sc_start_cmd = 'sc start ${viofs_svc_name}' + viofs_sc_query_cmd = 'sc query ${viofs_svc_name}' + viofs_sc_delete_cmd = 'sc delete ${viofs_svc_name}' + debug_log_operation = 'enable' + viofs_debug_enable_cmd = 'reg add HKLM\Software\VirtIO-FS /v DebugFlags /d 0xFFFFFFFF /t REG_DWORD' + viofs_log_enable_cmd = 'reg add HKLM\Software\VirtIO-FS /v DebugLogFile /d ${viofs_log_file} /t REG_SZ' + viofs_debug_delete_cmd = 'reg delete HKLM\Software\VirtIO-FS /v DebugFlags /f' + viofs_log_delete_cmd = 'reg delete HKLM\Software\VirtIO-FS /v DebugLogFile /f' + viofs_reg_query_cmd = 'reg query HKLM\Software\VirtIO-FS' + virtio_win_media_type = iso + cdroms += " virtio" + read_file_cmd = "type %s\${test_file}" + variants: + - cache_mode_auto: + fs_binary_extra_options += " --cache auto" + - cache_mode_always: + fs_binary_extra_options += " --cache always" + - cache_mode_never: + fs_binary_extra_options += " --cache never" + - cache_mode_metadata: + fs_binary_extra_options += " --cache metadata" + variants: + - @default: + - writeback: + only cache_mode_auto cache_mode_always + fs_binary_extra_options += " --writeback" + - dio: + only cache_mode_never + fs_binary_extra_options += " --allow-direct-io" + variants: + - @default: + - multifs: + filesystems += " fs2" + filesystems_migration += " targetfs2" + fs_source_dir_fs2 = /var/tmp/virtio_fs2_test + fs_source_dir_targetfs2 = /var/tmp/virtio_fs2_target + fs_target_fs2 = myfs2 + fs_dest_fs2 = /mnt/${fs_target_fs2} + fs_target_targetfs2 = ${fs_target_fs2} + fs_dest_targetfs2 = ${fs_dest_fs2} + + pre_command += " && mkdir -p ${fs_source_dir_fs2} ${fs_source_dir_targetfs2}" + pre_command += " && echo -e ${test_data} > ${fs_source_dir_fs2}/${test_file}" + pre_command += " && echo -e ${test_data} > ${fs_source_dir_targetfs2}/${test_file}" + post_command += " && rm -rf ${fs_source_dir_fs2} ${fs_source_dir_targetfs2}" + Windows: + clone_master = yes + master_images_clone = image1 + remove_image_image1 = yes + viofs_svc_name = WinFSP.Launcher + i386, i686: + cmd_path = 'C:\Program Files' + win_type = x86 + x86_64: + cmd_path = 'C:\Program Files (x86)' + win_type = x64 + viofs_sc_create_cmd = '"${cmd_path}\WinFsp\bin\fsreg.bat" virtiofs "${viofs_exe_path}" "-t %1 -m %2"' + instance_start_cmd = '"${cmd_path}\WinFsp\bin\launchctl-${win_type}.exe" start virtiofs viofs%s %s %s' + instance_stop_cmd = '"${cmd_path}\WinFsp\bin\launchctl-${win_type}.exe" stop virtiofs viofs%s' + volume_label_fs = X: + volume_label_fs2 = Y: diff --git a/qemu/tests/virtio_fs_localfs_migration.py b/qemu/tests/virtio_fs_localfs_migration.py new file mode 100644 index 0000000000..66546608d1 --- /dev/null +++ b/qemu/tests/virtio_fs_localfs_migration.py @@ -0,0 +1,188 @@ +import re + +from virttest import error_context, utils_disk, utils_misc, utils_test + +from provider import virtio_fs_utils + + +@error_context.context_aware +def run(test, params, env): + """ + Basic migration test with diffirent cache modes over localfs + Steps: + 1. Create a shared directory on the host and write a file + 2. Run the virtiofsd daemon on the host with different cache modes + 3. Boot the source guest with the virtiofs device in step1 + 4. Mount the virtiofs targets inside the guest + 5. Create a different directory on the host and write a file + 6. Run the virtiofsd daemon to share the directory in step5 + 7. Boot the target guest with the virtiofs device in step5 + 8. Do migration from the source guest to the target guest + 9. No error occurs, the virtiofs is mounted automatically and + the file content keeps the same on the target guest + + :param test: QEMU test object. + :param params: Dictionary with the test parameters. + :param env: Dictionary with test environment. + """ + + def create_service(session): + if os_type == "windows": + error_context.context("Create virtiofs service in guest.", test.log.info) + + driver_name = params["driver_name"] + + session = utils_test.qemu.windrv_check_running_verifier( + session, vm, test, driver_name + ) + viofs_svc_name = params["viofs_svc_name"] + virtio_fs_utils.create_viofs_service( + test, params, session, service=viofs_svc_name + ) + return session + + def delete_service(session): + if os_type == "windows": + error_context.context("Delete virtiofs service in guest.", test.log.info) + virtio_fs_utils.delete_viofs_serivce(test, params, session) + + def start_service(session): + def start_multifs_instance(fs_tag, fs_target, fs_volume_label): + """ + Only for windows and only for multiple shared directory. + """ + error_context.context( + "MultiFS-%s: Start virtiofs instance with" + " tag %s to %s." % (fs_tag, fs_target, fs_volume_label), + test.log.info, + ) + instance_start_cmd = params["instance_start_cmd"] + output = session.cmd_output( + instance_start_cmd % (fs_target, fs_target, fs_volume_label) + ) + if re.search("KO.*error", output, re.I): + test.fail( + "MultiFS-%s: Start virtiofs instance failed, " + "output is %s." % (fs_tag, output) + ) + + for fs in params.objects("filesystems"): + fs_params = params.object_params(fs) + + fs_target = fs_params["fs_target"] + fs_dest = fs_params["fs_dest"] + + if os_type == "linux": + utils_misc.make_dirs(fs_dest, session) + error_context.context( + "Mount virtiofs target %s to %s inside" + " guest." % (fs_target, fs_dest), + test.log.info, + ) + if not utils_disk.mount( + fs_target, fs_dest, "virtiofs", session=session + ): + utils_misc.safe_rmdir(fs_dest, session=session) + test.fail("Failed to mount virtiofs {fs_target}.") + else: + if params["viofs_svc_name"] == "VirtioFsSvc": + error_context.context( + "Start virtiofs service in guest.", test.log.info + ) + debug_log_operation = params.get("debug_log_operation") + if debug_log_operation: + session = virtio_fs_utils.operate_debug_log( + test, params, session, vm, debug_log_operation + ) + virtio_fs_utils.start_viofs_service(test, params, session) + else: + error_context.context( + "Start winfsp.launcher instance in guest.", test.log.info + ) + fs_volume_label = fs_params["volume_label"] + start_multifs_instance(fs, fs_target, fs_volume_label) + + fs_dest = "%s:" % virtio_fs_utils.get_virtiofs_driver_letter( + test, fs_target, session + ) + + guest_mnts[fs_target] = fs_dest + return session + + def stop_service(session): + error_context.context("Stop virtiofs service in guest.", test.log.info) + + if os_type == "linux": + for fs_target, fs_dest in guest_mnts.items(): + utils_disk.umount(fs_target, fs_dest, "virtiofs", session=session) + utils_misc.safe_rmdir(fs_dest, session=session) + else: + if params["viofs_svc_name"] == "WinFSP.Launcher": + for fs_target in guest_mnts.keys(): + error_context.context( + "Unmount fs with WinFsp.Launcher.z", test.log.info + ) + instance_stop_cmd = params["instance_stop_cmd"] + session.cmd(instance_stop_cmd % fs_target) + else: + if guest_mnts: + virtio_fs_utils.stop_viofs_service(test, params, session) + + def test_migration(session): + def check_service_activated(): + error_context.context( + "Check virtiofs service activated after migration.", + test.log.info, + ) + + tmo = params.get_numeric("active_timeout", 10) + if os_type == "linux": + for fs_target, fs_dest in guest_mnts.items(): + if not utils_misc.wait_for( + lambda: utils_disk.is_mount( + fs_target, fs_dest, "virtiofs", session=session + ), + tmo, + ): + test.log.fail(f"Failed to mount {fs_target}") + else: + for fs_target in guest_mnts.keys(): + virtio_fs_utils.get_virtiofs_driver_letter(test, fs_target, session) + + def check_file_content(): + error_context.context( + "Check file content after migration.", + test.log.info, + ) + + for fs_dest in guest_mnts.values(): + out = session.cmd_output(params["read_file_cmd"] % fs_dest).strip() + test.log.debug("File content: %s", out) + if out != params["test_data"]: + test.fail(f"Wrong file content found: {out}") + + # FIXME: Replace the vm's params to use a different shared virtio fs + vm.params["filesystems"] = vm.params["filesystems_migration"] + vm.migrate() + session = vm.wait_for_login() + + check_service_activated() + check_file_content() + return session + + guest_mnts = dict() + os_type = params["os_type"] + + vm = env.get_vm(params.get("main_vm")) + vm.verify_alive() + session = vm.wait_for_login() + + try: + session = create_service(session) + session = start_service(session) + session = test_migration(session) + finally: + try: + stop_service(session) + finally: + delete_service(session)